Program Listing for File vulkan-argsprinter-structs.inl

↰ Return to documentation for file (include/argsprinter/vulkan-argsprinter-structs.inl)

/******************************************************************************
© Intel Corporation.
This software and the related documents are Intel copyrighted materials,
and your use of them is governed by the express license under which they
were provided to you ("License"). Unless the License provides otherwise,
you may not use, modify, copy, publish, distribute, disclose or transmit
this software or the related documents without Intel's prior written
permission.
 This software and the related documents are provided as is, with no express
or implied warranties, other than those that are expressly stated in the
License.
******************************************************************************/
#pragma once
#include <algorithm>
#include <iosfwd>
#include <string>
template <> void Print<VkAabbPositionsKHR>(VkAabbPositionsKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAccelerationStructureBuildGeometryInfoKHR>(VkAccelerationStructureBuildGeometryInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAccelerationStructureBuildRangeInfoKHR>(VkAccelerationStructureBuildRangeInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAccelerationStructureBuildSizesInfoKHR>(VkAccelerationStructureBuildSizesInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAccelerationStructureCaptureDescriptorDataInfoEXT>(VkAccelerationStructureCaptureDescriptorDataInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAccelerationStructureCreateInfoKHR>(VkAccelerationStructureCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAccelerationStructureCreateInfoNV>(VkAccelerationStructureCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAccelerationStructureDeviceAddressInfoKHR>(VkAccelerationStructureDeviceAddressInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAccelerationStructureGeometryAabbsDataKHR>(VkAccelerationStructureGeometryAabbsDataKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAccelerationStructureGeometryInstancesDataKHR>(VkAccelerationStructureGeometryInstancesDataKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAccelerationStructureGeometryKHR>(VkAccelerationStructureGeometryKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAccelerationStructureGeometryMotionTrianglesDataNV>(VkAccelerationStructureGeometryMotionTrianglesDataNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAccelerationStructureGeometryTrianglesDataKHR>(VkAccelerationStructureGeometryTrianglesDataKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAccelerationStructureInfoNV>(VkAccelerationStructureInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAccelerationStructureInstanceKHR>(VkAccelerationStructureInstanceKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAccelerationStructureMatrixMotionInstanceNV>(VkAccelerationStructureMatrixMotionInstanceNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAccelerationStructureMemoryRequirementsInfoNV>(VkAccelerationStructureMemoryRequirementsInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAccelerationStructureMotionInfoNV>(VkAccelerationStructureMotionInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAccelerationStructureMotionInstanceNV>(VkAccelerationStructureMotionInstanceNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAccelerationStructureSRTMotionInstanceNV>(VkAccelerationStructureSRTMotionInstanceNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAccelerationStructureTrianglesOpacityMicromapEXT>(VkAccelerationStructureTrianglesOpacityMicromapEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAccelerationStructureVersionInfoKHR>(VkAccelerationStructureVersionInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAcquireNextImageInfoKHR>(VkAcquireNextImageInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAcquireProfilingLockInfoKHR>(VkAcquireProfilingLockInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAllocationCallbacks>(VkAllocationCallbacks const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAmigoProfilingSubmitInfoSEC>(VkAmigoProfilingSubmitInfoSEC const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkApplicationInfo>(VkApplicationInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAttachmentDescription>(VkAttachmentDescription const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAttachmentDescription2>(VkAttachmentDescription2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAttachmentDescriptionStencilLayout>(VkAttachmentDescriptionStencilLayout const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAttachmentReference>(VkAttachmentReference const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAttachmentReference2>(VkAttachmentReference2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAttachmentReferenceStencilLayout>(VkAttachmentReferenceStencilLayout const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAttachmentSampleCountInfoAMD>(VkAttachmentSampleCountInfoAMD const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkAttachmentSampleLocationsEXT>(VkAttachmentSampleLocationsEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkBaseInStructure>(VkBaseInStructure const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkBaseOutStructure>(VkBaseOutStructure const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkBindAccelerationStructureMemoryInfoNV>(VkBindAccelerationStructureMemoryInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkBindBufferMemoryDeviceGroupInfo>(VkBindBufferMemoryDeviceGroupInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkBindBufferMemoryInfo>(VkBindBufferMemoryInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkBindImageMemoryDeviceGroupInfo>(VkBindImageMemoryDeviceGroupInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkBindImageMemoryInfo>(VkBindImageMemoryInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkBindImageMemorySwapchainInfoKHR>(VkBindImageMemorySwapchainInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkBindImagePlaneMemoryInfo>(VkBindImagePlaneMemoryInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkBindIndexBufferIndirectCommandNV>(VkBindIndexBufferIndirectCommandNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkBindShaderGroupIndirectCommandNV>(VkBindShaderGroupIndirectCommandNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkBindSparseInfo>(VkBindSparseInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkBindVertexBufferIndirectCommandNV>(VkBindVertexBufferIndirectCommandNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkBindVideoSessionMemoryInfoKHR>(VkBindVideoSessionMemoryInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkBlitImageInfo2>(VkBlitImageInfo2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkBufferCaptureDescriptorDataInfoEXT>(VkBufferCaptureDescriptorDataInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkBufferCopy>(VkBufferCopy const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkBufferCopy2>(VkBufferCopy2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkBufferCreateInfo>(VkBufferCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkBufferDeviceAddressCreateInfoEXT>(VkBufferDeviceAddressCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkBufferDeviceAddressInfo>(VkBufferDeviceAddressInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkBufferImageCopy>(VkBufferImageCopy const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkBufferImageCopy2>(VkBufferImageCopy2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkBufferMemoryBarrier>(VkBufferMemoryBarrier const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkBufferMemoryBarrier2>(VkBufferMemoryBarrier2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkBufferMemoryRequirementsInfo2>(VkBufferMemoryRequirementsInfo2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkBufferOpaqueCaptureAddressCreateInfo>(VkBufferOpaqueCaptureAddressCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkBufferViewCreateInfo>(VkBufferViewCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCalibratedTimestampInfoEXT>(VkCalibratedTimestampInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCheckpointData2NV>(VkCheckpointData2NV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCheckpointDataNV>(VkCheckpointDataNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkClearAttachment>(VkClearAttachment const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkClearDepthStencilValue>(VkClearDepthStencilValue const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkClearRect>(VkClearRect const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCoarseSampleLocationNV>(VkCoarseSampleLocationNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCoarseSampleOrderCustomNV>(VkCoarseSampleOrderCustomNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkColorBlendAdvancedEXT>(VkColorBlendAdvancedEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkColorBlendEquationEXT>(VkColorBlendEquationEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCommandBufferAllocateInfo>(VkCommandBufferAllocateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCommandBufferBeginInfo>(VkCommandBufferBeginInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCommandBufferInheritanceConditionalRenderingInfoEXT>(VkCommandBufferInheritanceConditionalRenderingInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCommandBufferInheritanceInfo>(VkCommandBufferInheritanceInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCommandBufferInheritanceRenderPassTransformInfoQCOM>(VkCommandBufferInheritanceRenderPassTransformInfoQCOM const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCommandBufferInheritanceRenderingInfo>(VkCommandBufferInheritanceRenderingInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCommandBufferInheritanceViewportScissorInfoNV>(VkCommandBufferInheritanceViewportScissorInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCommandBufferSubmitInfo>(VkCommandBufferSubmitInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCommandPoolCreateInfo>(VkCommandPoolCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkComponentMapping>(VkComponentMapping const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkComputePipelineCreateInfo>(VkComputePipelineCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkConditionalRenderingBeginInfoEXT>(VkConditionalRenderingBeginInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkConformanceVersion>(VkConformanceVersion const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCooperativeMatrixPropertiesNV>(VkCooperativeMatrixPropertiesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCopyAccelerationStructureInfoKHR>(VkCopyAccelerationStructureInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCopyAccelerationStructureToMemoryInfoKHR>(VkCopyAccelerationStructureToMemoryInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCopyBufferInfo2>(VkCopyBufferInfo2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCopyBufferToImageInfo2>(VkCopyBufferToImageInfo2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCopyCommandTransformInfoQCOM>(VkCopyCommandTransformInfoQCOM const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCopyDescriptorSet>(VkCopyDescriptorSet const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCopyImageInfo2>(VkCopyImageInfo2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCopyImageToBufferInfo2>(VkCopyImageToBufferInfo2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCopyMemoryIndirectCommandNV>(VkCopyMemoryIndirectCommandNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCopyMemoryToAccelerationStructureInfoKHR>(VkCopyMemoryToAccelerationStructureInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCopyMemoryToImageIndirectCommandNV>(VkCopyMemoryToImageIndirectCommandNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCopyMemoryToMicromapInfoEXT>(VkCopyMemoryToMicromapInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCopyMicromapInfoEXT>(VkCopyMicromapInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCopyMicromapToMemoryInfoEXT>(VkCopyMicromapToMemoryInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCuFunctionCreateInfoNVX>(VkCuFunctionCreateInfoNVX const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCuLaunchInfoNVX>(VkCuLaunchInfoNVX const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkCuModuleCreateInfoNVX>(VkCuModuleCreateInfoNVX const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDebugMarkerMarkerInfoEXT>(VkDebugMarkerMarkerInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDebugMarkerObjectNameInfoEXT>(VkDebugMarkerObjectNameInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDebugMarkerObjectTagInfoEXT>(VkDebugMarkerObjectTagInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDebugReportCallbackCreateInfoEXT>(VkDebugReportCallbackCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDebugUtilsLabelEXT>(VkDebugUtilsLabelEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDebugUtilsMessengerCallbackDataEXT>(VkDebugUtilsMessengerCallbackDataEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDebugUtilsMessengerCreateInfoEXT>(VkDebugUtilsMessengerCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDebugUtilsObjectNameInfoEXT>(VkDebugUtilsObjectNameInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDebugUtilsObjectTagInfoEXT>(VkDebugUtilsObjectTagInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDecompressMemoryRegionNV>(VkDecompressMemoryRegionNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDedicatedAllocationBufferCreateInfoNV>(VkDedicatedAllocationBufferCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDedicatedAllocationImageCreateInfoNV>(VkDedicatedAllocationImageCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDedicatedAllocationMemoryAllocateInfoNV>(VkDedicatedAllocationMemoryAllocateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDependencyInfo>(VkDependencyInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDescriptorAddressInfoEXT>(VkDescriptorAddressInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDescriptorBufferBindingInfoEXT>(VkDescriptorBufferBindingInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDescriptorBufferBindingPushDescriptorBufferHandleEXT>(VkDescriptorBufferBindingPushDescriptorBufferHandleEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDescriptorBufferInfo>(VkDescriptorBufferInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDescriptorGetInfoEXT>(VkDescriptorGetInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDescriptorImageInfo>(VkDescriptorImageInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDescriptorPoolCreateInfo>(VkDescriptorPoolCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDescriptorPoolInlineUniformBlockCreateInfo>(VkDescriptorPoolInlineUniformBlockCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDescriptorPoolSize>(VkDescriptorPoolSize const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDescriptorSetAllocateInfo>(VkDescriptorSetAllocateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDescriptorSetBindingReferenceVALVE>(VkDescriptorSetBindingReferenceVALVE const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDescriptorSetLayoutBinding>(VkDescriptorSetLayoutBinding const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDescriptorSetLayoutBindingFlagsCreateInfo>(VkDescriptorSetLayoutBindingFlagsCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDescriptorSetLayoutCreateInfo>(VkDescriptorSetLayoutCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDescriptorSetLayoutHostMappingInfoVALVE>(VkDescriptorSetLayoutHostMappingInfoVALVE const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDescriptorSetLayoutSupport>(VkDescriptorSetLayoutSupport const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDescriptorSetVariableDescriptorCountAllocateInfo>(VkDescriptorSetVariableDescriptorCountAllocateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDescriptorSetVariableDescriptorCountLayoutSupport>(VkDescriptorSetVariableDescriptorCountLayoutSupport const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDescriptorUpdateTemplateCreateInfo>(VkDescriptorUpdateTemplateCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDescriptorUpdateTemplateEntry>(VkDescriptorUpdateTemplateEntry const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDeviceAddressBindingCallbackDataEXT>(VkDeviceAddressBindingCallbackDataEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDeviceBufferMemoryRequirements>(VkDeviceBufferMemoryRequirements const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDeviceCreateInfo>(VkDeviceCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDeviceDeviceMemoryReportCreateInfoEXT>(VkDeviceDeviceMemoryReportCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDeviceDiagnosticsConfigCreateInfoNV>(VkDeviceDiagnosticsConfigCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDeviceEventInfoEXT>(VkDeviceEventInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDeviceFaultAddressInfoEXT>(VkDeviceFaultAddressInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDeviceFaultCountsEXT>(VkDeviceFaultCountsEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDeviceFaultInfoEXT>(VkDeviceFaultInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDeviceFaultVendorBinaryHeaderVersionOneEXT>(VkDeviceFaultVendorBinaryHeaderVersionOneEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDeviceFaultVendorInfoEXT>(VkDeviceFaultVendorInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDeviceGroupBindSparseInfo>(VkDeviceGroupBindSparseInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDeviceGroupCommandBufferBeginInfo>(VkDeviceGroupCommandBufferBeginInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDeviceGroupDeviceCreateInfo>(VkDeviceGroupDeviceCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDeviceGroupPresentCapabilitiesKHR>(VkDeviceGroupPresentCapabilitiesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDeviceGroupPresentInfoKHR>(VkDeviceGroupPresentInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDeviceGroupRenderPassBeginInfo>(VkDeviceGroupRenderPassBeginInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDeviceGroupSubmitInfo>(VkDeviceGroupSubmitInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDeviceGroupSwapchainCreateInfoKHR>(VkDeviceGroupSwapchainCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDeviceImageMemoryRequirements>(VkDeviceImageMemoryRequirements const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDeviceMemoryOpaqueCaptureAddressInfo>(VkDeviceMemoryOpaqueCaptureAddressInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDeviceMemoryOverallocationCreateInfoAMD>(VkDeviceMemoryOverallocationCreateInfoAMD const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDeviceMemoryReportCallbackDataEXT>(VkDeviceMemoryReportCallbackDataEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDevicePrivateDataCreateInfo>(VkDevicePrivateDataCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDeviceQueueCreateInfo>(VkDeviceQueueCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDeviceQueueGlobalPriorityCreateInfoKHR>(VkDeviceQueueGlobalPriorityCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDeviceQueueInfo2>(VkDeviceQueueInfo2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDirectDriverLoadingInfoLUNARG>(VkDirectDriverLoadingInfoLUNARG const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDirectDriverLoadingListLUNARG>(VkDirectDriverLoadingListLUNARG const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDispatchIndirectCommand>(VkDispatchIndirectCommand const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDisplayEventInfoEXT>(VkDisplayEventInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDisplayModeCreateInfoKHR>(VkDisplayModeCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDisplayModeParametersKHR>(VkDisplayModeParametersKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDisplayModeProperties2KHR>(VkDisplayModeProperties2KHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDisplayModePropertiesKHR>(VkDisplayModePropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDisplayNativeHdrSurfaceCapabilitiesAMD>(VkDisplayNativeHdrSurfaceCapabilitiesAMD const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDisplayPlaneCapabilities2KHR>(VkDisplayPlaneCapabilities2KHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDisplayPlaneCapabilitiesKHR>(VkDisplayPlaneCapabilitiesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDisplayPlaneInfo2KHR>(VkDisplayPlaneInfo2KHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDisplayPlaneProperties2KHR>(VkDisplayPlaneProperties2KHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDisplayPlanePropertiesKHR>(VkDisplayPlanePropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDisplayPowerInfoEXT>(VkDisplayPowerInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDisplayPresentInfoKHR>(VkDisplayPresentInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDisplayProperties2KHR>(VkDisplayProperties2KHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDisplayPropertiesKHR>(VkDisplayPropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDisplaySurfaceCreateInfoKHR>(VkDisplaySurfaceCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDrawIndexedIndirectCommand>(VkDrawIndexedIndirectCommand const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDrawIndirectCommand>(VkDrawIndirectCommand const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDrawMeshTasksIndirectCommandEXT>(VkDrawMeshTasksIndirectCommandEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDrawMeshTasksIndirectCommandNV>(VkDrawMeshTasksIndirectCommandNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDrmFormatModifierProperties2EXT>(VkDrmFormatModifierProperties2EXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDrmFormatModifierPropertiesEXT>(VkDrmFormatModifierPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDrmFormatModifierPropertiesList2EXT>(VkDrmFormatModifierPropertiesList2EXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkDrmFormatModifierPropertiesListEXT>(VkDrmFormatModifierPropertiesListEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkEventCreateInfo>(VkEventCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkExportFenceCreateInfo>(VkExportFenceCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkExportMemoryAllocateInfo>(VkExportMemoryAllocateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkExportMemoryAllocateInfoNV>(VkExportMemoryAllocateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkExportSemaphoreCreateInfo>(VkExportSemaphoreCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkExtensionProperties>(VkExtensionProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkExtent2D>(VkExtent2D const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkExtent3D>(VkExtent3D const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkExternalBufferProperties>(VkExternalBufferProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkExternalFenceProperties>(VkExternalFenceProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkExternalImageFormatProperties>(VkExternalImageFormatProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkExternalImageFormatPropertiesNV>(VkExternalImageFormatPropertiesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkExternalMemoryBufferCreateInfo>(VkExternalMemoryBufferCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkExternalMemoryImageCreateInfo>(VkExternalMemoryImageCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkExternalMemoryImageCreateInfoNV>(VkExternalMemoryImageCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkExternalMemoryProperties>(VkExternalMemoryProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkExternalSemaphoreProperties>(VkExternalSemaphoreProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkFenceCreateInfo>(VkFenceCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkFenceGetFdInfoKHR>(VkFenceGetFdInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkFilterCubicImageViewImageFormatPropertiesEXT>(VkFilterCubicImageViewImageFormatPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkFormatProperties>(VkFormatProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkFormatProperties2>(VkFormatProperties2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkFormatProperties3>(VkFormatProperties3 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkFragmentShadingRateAttachmentInfoKHR>(VkFragmentShadingRateAttachmentInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkFramebufferAttachmentImageInfo>(VkFramebufferAttachmentImageInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkFramebufferAttachmentsCreateInfo>(VkFramebufferAttachmentsCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkFramebufferCreateInfo>(VkFramebufferCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkFramebufferMixedSamplesCombinationNV>(VkFramebufferMixedSamplesCombinationNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkGeneratedCommandsInfoNV>(VkGeneratedCommandsInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkGeneratedCommandsMemoryRequirementsInfoNV>(VkGeneratedCommandsMemoryRequirementsInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkGeometryAABBNV>(VkGeometryAABBNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkGeometryDataNV>(VkGeometryDataNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkGeometryNV>(VkGeometryNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkGeometryTrianglesNV>(VkGeometryTrianglesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkGraphicsPipelineCreateInfo>(VkGraphicsPipelineCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkGraphicsPipelineLibraryCreateInfoEXT>(VkGraphicsPipelineLibraryCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkGraphicsPipelineShaderGroupsCreateInfoNV>(VkGraphicsPipelineShaderGroupsCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkGraphicsShaderGroupCreateInfoNV>(VkGraphicsShaderGroupCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkHdrMetadataEXT>(VkHdrMetadataEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkHeadlessSurfaceCreateInfoEXT>(VkHeadlessSurfaceCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageBlit>(VkImageBlit const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageBlit2>(VkImageBlit2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageCaptureDescriptorDataInfoEXT>(VkImageCaptureDescriptorDataInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageCompressionControlEXT>(VkImageCompressionControlEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageCompressionPropertiesEXT>(VkImageCompressionPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageCopy>(VkImageCopy const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageCopy2>(VkImageCopy2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageCreateInfo>(VkImageCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageDrmFormatModifierExplicitCreateInfoEXT>(VkImageDrmFormatModifierExplicitCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageDrmFormatModifierListCreateInfoEXT>(VkImageDrmFormatModifierListCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageDrmFormatModifierPropertiesEXT>(VkImageDrmFormatModifierPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageFormatListCreateInfo>(VkImageFormatListCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageFormatProperties>(VkImageFormatProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageFormatProperties2>(VkImageFormatProperties2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageMemoryBarrier>(VkImageMemoryBarrier const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageMemoryBarrier2>(VkImageMemoryBarrier2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageMemoryRequirementsInfo2>(VkImageMemoryRequirementsInfo2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImagePlaneMemoryRequirementsInfo>(VkImagePlaneMemoryRequirementsInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageResolve>(VkImageResolve const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageResolve2>(VkImageResolve2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageSparseMemoryRequirementsInfo2>(VkImageSparseMemoryRequirementsInfo2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageStencilUsageCreateInfo>(VkImageStencilUsageCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageSubresource>(VkImageSubresource const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageSubresource2EXT>(VkImageSubresource2EXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageSubresourceLayers>(VkImageSubresourceLayers const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageSubresourceRange>(VkImageSubresourceRange const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageSwapchainCreateInfoKHR>(VkImageSwapchainCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageViewASTCDecodeModeEXT>(VkImageViewASTCDecodeModeEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageViewAddressPropertiesNVX>(VkImageViewAddressPropertiesNVX const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageViewCaptureDescriptorDataInfoEXT>(VkImageViewCaptureDescriptorDataInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageViewCreateInfo>(VkImageViewCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageViewHandleInfoNVX>(VkImageViewHandleInfoNVX const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageViewMinLodCreateInfoEXT>(VkImageViewMinLodCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageViewSampleWeightCreateInfoQCOM>(VkImageViewSampleWeightCreateInfoQCOM const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImageViewUsageCreateInfo>(VkImageViewUsageCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImportFenceFdInfoKHR>(VkImportFenceFdInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImportMemoryFdInfoKHR>(VkImportMemoryFdInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImportMemoryHostPointerInfoEXT>(VkImportMemoryHostPointerInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkImportSemaphoreFdInfoKHR>(VkImportSemaphoreFdInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkIndirectCommandsLayoutCreateInfoNV>(VkIndirectCommandsLayoutCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkIndirectCommandsLayoutTokenNV>(VkIndirectCommandsLayoutTokenNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkIndirectCommandsStreamNV>(VkIndirectCommandsStreamNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkInitializePerformanceApiInfoINTEL>(VkInitializePerformanceApiInfoINTEL const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkInputAttachmentAspectReference>(VkInputAttachmentAspectReference const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkInstanceCreateInfo>(VkInstanceCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkLayerProperties>(VkLayerProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkMappedMemoryRange>(VkMappedMemoryRange const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkMemoryAllocateFlagsInfo>(VkMemoryAllocateFlagsInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkMemoryAllocateInfo>(VkMemoryAllocateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkMemoryBarrier>(VkMemoryBarrier const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkMemoryBarrier2>(VkMemoryBarrier2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkMemoryDedicatedAllocateInfo>(VkMemoryDedicatedAllocateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkMemoryDedicatedRequirements>(VkMemoryDedicatedRequirements const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkMemoryFdPropertiesKHR>(VkMemoryFdPropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkMemoryGetFdInfoKHR>(VkMemoryGetFdInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkMemoryGetRemoteAddressInfoNV>(VkMemoryGetRemoteAddressInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkMemoryHeap>(VkMemoryHeap const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkMemoryHostPointerPropertiesEXT>(VkMemoryHostPointerPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkMemoryOpaqueCaptureAddressAllocateInfo>(VkMemoryOpaqueCaptureAddressAllocateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkMemoryPriorityAllocateInfoEXT>(VkMemoryPriorityAllocateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkMemoryRequirements>(VkMemoryRequirements const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkMemoryRequirements2>(VkMemoryRequirements2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkMemoryType>(VkMemoryType const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkMicromapBuildInfoEXT>(VkMicromapBuildInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkMicromapBuildSizesInfoEXT>(VkMicromapBuildSizesInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkMicromapCreateInfoEXT>(VkMicromapCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkMicromapTriangleEXT>(VkMicromapTriangleEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkMicromapUsageEXT>(VkMicromapUsageEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkMicromapVersionInfoEXT>(VkMicromapVersionInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkMultiDrawIndexedInfoEXT>(VkMultiDrawIndexedInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkMultiDrawInfoEXT>(VkMultiDrawInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkMultisamplePropertiesEXT>(VkMultisamplePropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkMultisampledRenderToSingleSampledInfoEXT>(VkMultisampledRenderToSingleSampledInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkMultiviewPerViewAttributesInfoNVX>(VkMultiviewPerViewAttributesInfoNVX const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkMutableDescriptorTypeCreateInfoEXT>(VkMutableDescriptorTypeCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkMutableDescriptorTypeListEXT>(VkMutableDescriptorTypeListEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkOffset2D>(VkOffset2D const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkOffset3D>(VkOffset3D const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkOpaqueCaptureDescriptorDataCreateInfoEXT>(VkOpaqueCaptureDescriptorDataCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkOpticalFlowExecuteInfoNV>(VkOpticalFlowExecuteInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkOpticalFlowImageFormatInfoNV>(VkOpticalFlowImageFormatInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkOpticalFlowImageFormatPropertiesNV>(VkOpticalFlowImageFormatPropertiesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkOpticalFlowSessionCreateInfoNV>(VkOpticalFlowSessionCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkOpticalFlowSessionCreatePrivateDataInfoNV>(VkOpticalFlowSessionCreatePrivateDataInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPastPresentationTimingGOOGLE>(VkPastPresentationTimingGOOGLE const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPerformanceConfigurationAcquireInfoINTEL>(VkPerformanceConfigurationAcquireInfoINTEL const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPerformanceCounterDescriptionKHR>(VkPerformanceCounterDescriptionKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPerformanceCounterKHR>(VkPerformanceCounterKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPerformanceMarkerInfoINTEL>(VkPerformanceMarkerInfoINTEL const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPerformanceOverrideInfoINTEL>(VkPerformanceOverrideInfoINTEL const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPerformanceQuerySubmitInfoKHR>(VkPerformanceQuerySubmitInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPerformanceStreamMarkerInfoINTEL>(VkPerformanceStreamMarkerInfoINTEL const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPerformanceValueINTEL>(VkPerformanceValueINTEL const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDevice16BitStorageFeatures>(VkPhysicalDevice16BitStorageFeatures const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDevice4444FormatsFeaturesEXT>(VkPhysicalDevice4444FormatsFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDevice8BitStorageFeatures>(VkPhysicalDevice8BitStorageFeatures const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceASTCDecodeFeaturesEXT>(VkPhysicalDeviceASTCDecodeFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceAccelerationStructureFeaturesKHR>(VkPhysicalDeviceAccelerationStructureFeaturesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceAccelerationStructurePropertiesKHR>(VkPhysicalDeviceAccelerationStructurePropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceAddressBindingReportFeaturesEXT>(VkPhysicalDeviceAddressBindingReportFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceAmigoProfilingFeaturesSEC>(VkPhysicalDeviceAmigoProfilingFeaturesSEC const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT>(VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT>(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT>(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT>(VkPhysicalDeviceBorderColorSwizzleFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceBufferDeviceAddressFeatures>(VkPhysicalDeviceBufferDeviceAddressFeatures const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT>(VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI>(VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI>(VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceCoherentMemoryFeaturesAMD>(VkPhysicalDeviceCoherentMemoryFeaturesAMD const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceColorWriteEnableFeaturesEXT>(VkPhysicalDeviceColorWriteEnableFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV>(VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceConditionalRenderingFeaturesEXT>(VkPhysicalDeviceConditionalRenderingFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceConservativeRasterizationPropertiesEXT>(VkPhysicalDeviceConservativeRasterizationPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceCooperativeMatrixFeaturesNV>(VkPhysicalDeviceCooperativeMatrixFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceCooperativeMatrixPropertiesNV>(VkPhysicalDeviceCooperativeMatrixPropertiesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceCopyMemoryIndirectFeaturesNV>(VkPhysicalDeviceCopyMemoryIndirectFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceCopyMemoryIndirectPropertiesNV>(VkPhysicalDeviceCopyMemoryIndirectPropertiesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceCornerSampledImageFeaturesNV>(VkPhysicalDeviceCornerSampledImageFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceCoverageReductionModeFeaturesNV>(VkPhysicalDeviceCoverageReductionModeFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceCustomBorderColorFeaturesEXT>(VkPhysicalDeviceCustomBorderColorFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceCustomBorderColorPropertiesEXT>(VkPhysicalDeviceCustomBorderColorPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>(VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceDepthClampZeroOneFeaturesEXT>(VkPhysicalDeviceDepthClampZeroOneFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceDepthClipControlFeaturesEXT>(VkPhysicalDeviceDepthClipControlFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceDepthClipEnableFeaturesEXT>(VkPhysicalDeviceDepthClipEnableFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceDepthStencilResolveProperties>(VkPhysicalDeviceDepthStencilResolveProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT>(VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceDescriptorBufferFeaturesEXT>(VkPhysicalDeviceDescriptorBufferFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceDescriptorBufferPropertiesEXT>(VkPhysicalDeviceDescriptorBufferPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceDescriptorIndexingFeatures>(VkPhysicalDeviceDescriptorIndexingFeatures const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceDescriptorIndexingProperties>(VkPhysicalDeviceDescriptorIndexingProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE>(VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV>(VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV>(VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT>(VkPhysicalDeviceDeviceMemoryReportFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceDiagnosticsConfigFeaturesNV>(VkPhysicalDeviceDiagnosticsConfigFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceDiscardRectanglePropertiesEXT>(VkPhysicalDeviceDiscardRectanglePropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceDriverProperties>(VkPhysicalDeviceDriverProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceDrmPropertiesEXT>(VkPhysicalDeviceDrmPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceDynamicRenderingFeatures>(VkPhysicalDeviceDynamicRenderingFeatures const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceExclusiveScissorFeaturesNV>(VkPhysicalDeviceExclusiveScissorFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT>(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceExtendedDynamicState3PropertiesEXT>(VkPhysicalDeviceExtendedDynamicState3PropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT>(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceExternalBufferInfo>(VkPhysicalDeviceExternalBufferInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceExternalFenceInfo>(VkPhysicalDeviceExternalFenceInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceExternalImageFormatInfo>(VkPhysicalDeviceExternalImageFormatInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceExternalMemoryHostPropertiesEXT>(VkPhysicalDeviceExternalMemoryHostPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceExternalMemoryRDMAFeaturesNV>(VkPhysicalDeviceExternalMemoryRDMAFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceExternalSemaphoreInfo>(VkPhysicalDeviceExternalSemaphoreInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceFaultFeaturesEXT>(VkPhysicalDeviceFaultFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceFeatures>(VkPhysicalDeviceFeatures const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceFeatures2>(VkPhysicalDeviceFeatures2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceFloatControlsProperties>(VkPhysicalDeviceFloatControlsProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT>(VkPhysicalDeviceFragmentDensityMap2FeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT>(VkPhysicalDeviceFragmentDensityMap2PropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceFragmentDensityMapFeaturesEXT>(VkPhysicalDeviceFragmentDensityMapFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>(VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>(VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceFragmentDensityMapPropertiesEXT>(VkPhysicalDeviceFragmentDensityMapPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR>(VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR>(VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT>(VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV>(VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV>(VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceFragmentShadingRateFeaturesKHR>(VkPhysicalDeviceFragmentShadingRateFeaturesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceFragmentShadingRateKHR>(VkPhysicalDeviceFragmentShadingRateKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceFragmentShadingRatePropertiesKHR>(VkPhysicalDeviceFragmentShadingRatePropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR>(VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT>(VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT>(VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceGroupProperties>(VkPhysicalDeviceGroupProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceHostQueryResetFeatures>(VkPhysicalDeviceHostQueryResetFeatures const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceIDProperties>(VkPhysicalDeviceIDProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT>(VkPhysicalDeviceImage2DViewOf3DFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceImageCompressionControlFeaturesEXT>(VkPhysicalDeviceImageCompressionControlFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT>(VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceImageDrmFormatModifierInfoEXT>(VkPhysicalDeviceImageDrmFormatModifierInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceImageFormatInfo2>(VkPhysicalDeviceImageFormatInfo2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceImageProcessingFeaturesQCOM>(VkPhysicalDeviceImageProcessingFeaturesQCOM const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceImageProcessingPropertiesQCOM>(VkPhysicalDeviceImageProcessingPropertiesQCOM const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceImageRobustnessFeatures>(VkPhysicalDeviceImageRobustnessFeatures const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceImageViewImageFormatInfoEXT>(VkPhysicalDeviceImageViewImageFormatInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceImageViewMinLodFeaturesEXT>(VkPhysicalDeviceImageViewMinLodFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceImagelessFramebufferFeatures>(VkPhysicalDeviceImagelessFramebufferFeatures const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceIndexTypeUint8FeaturesEXT>(VkPhysicalDeviceIndexTypeUint8FeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceInheritedViewportScissorFeaturesNV>(VkPhysicalDeviceInheritedViewportScissorFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceInlineUniformBlockFeatures>(VkPhysicalDeviceInlineUniformBlockFeatures const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceInlineUniformBlockProperties>(VkPhysicalDeviceInlineUniformBlockProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceInvocationMaskFeaturesHUAWEI>(VkPhysicalDeviceInvocationMaskFeaturesHUAWEI const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceLegacyDitheringFeaturesEXT>(VkPhysicalDeviceLegacyDitheringFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceLimits>(VkPhysicalDeviceLimits const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceLineRasterizationFeaturesEXT>(VkPhysicalDeviceLineRasterizationFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceLineRasterizationPropertiesEXT>(VkPhysicalDeviceLineRasterizationPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceLinearColorAttachmentFeaturesNV>(VkPhysicalDeviceLinearColorAttachmentFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceMaintenance3Properties>(VkPhysicalDeviceMaintenance3Properties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceMaintenance4Features>(VkPhysicalDeviceMaintenance4Features const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceMaintenance4Properties>(VkPhysicalDeviceMaintenance4Properties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceMemoryBudgetPropertiesEXT>(VkPhysicalDeviceMemoryBudgetPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceMemoryDecompressionFeaturesNV>(VkPhysicalDeviceMemoryDecompressionFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceMemoryDecompressionPropertiesNV>(VkPhysicalDeviceMemoryDecompressionPropertiesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceMemoryPriorityFeaturesEXT>(VkPhysicalDeviceMemoryPriorityFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceMemoryProperties>(VkPhysicalDeviceMemoryProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceMemoryProperties2>(VkPhysicalDeviceMemoryProperties2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceMeshShaderFeaturesEXT>(VkPhysicalDeviceMeshShaderFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceMeshShaderFeaturesNV>(VkPhysicalDeviceMeshShaderFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceMeshShaderPropertiesEXT>(VkPhysicalDeviceMeshShaderPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceMeshShaderPropertiesNV>(VkPhysicalDeviceMeshShaderPropertiesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceMultiDrawFeaturesEXT>(VkPhysicalDeviceMultiDrawFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceMultiDrawPropertiesEXT>(VkPhysicalDeviceMultiDrawPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT>(VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceMultiviewFeatures>(VkPhysicalDeviceMultiviewFeatures const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>(VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM>(VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceMultiviewProperties>(VkPhysicalDeviceMultiviewProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT>(VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT>(VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceOpacityMicromapFeaturesEXT>(VkPhysicalDeviceOpacityMicromapFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceOpacityMicromapPropertiesEXT>(VkPhysicalDeviceOpacityMicromapPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceOpticalFlowFeaturesNV>(VkPhysicalDeviceOpticalFlowFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceOpticalFlowPropertiesNV>(VkPhysicalDeviceOpticalFlowPropertiesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDevicePCIBusInfoPropertiesEXT>(VkPhysicalDevicePCIBusInfoPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT>(VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDevicePerformanceQueryFeaturesKHR>(VkPhysicalDevicePerformanceQueryFeaturesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDevicePerformanceQueryPropertiesKHR>(VkPhysicalDevicePerformanceQueryPropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDevicePipelineCreationCacheControlFeatures>(VkPhysicalDevicePipelineCreationCacheControlFeatures const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR>(VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDevicePipelinePropertiesFeaturesEXT>(VkPhysicalDevicePipelinePropertiesFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDevicePipelineProtectedAccessFeaturesEXT>(VkPhysicalDevicePipelineProtectedAccessFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDevicePipelineRobustnessFeaturesEXT>(VkPhysicalDevicePipelineRobustnessFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDevicePipelineRobustnessPropertiesEXT>(VkPhysicalDevicePipelineRobustnessPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDevicePointClippingProperties>(VkPhysicalDevicePointClippingProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDevicePortabilitySubsetFeaturesKHR>(VkPhysicalDevicePortabilitySubsetFeaturesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDevicePortabilitySubsetPropertiesKHR>(VkPhysicalDevicePortabilitySubsetPropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDevicePresentBarrierFeaturesNV>(VkPhysicalDevicePresentBarrierFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDevicePresentIdFeaturesKHR>(VkPhysicalDevicePresentIdFeaturesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDevicePresentWaitFeaturesKHR>(VkPhysicalDevicePresentWaitFeaturesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT>(VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT>(VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDevicePrivateDataFeatures>(VkPhysicalDevicePrivateDataFeatures const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceProperties>(VkPhysicalDeviceProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceProperties2>(VkPhysicalDeviceProperties2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceProtectedMemoryFeatures>(VkPhysicalDeviceProtectedMemoryFeatures const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceProtectedMemoryProperties>(VkPhysicalDeviceProtectedMemoryProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceProvokingVertexFeaturesEXT>(VkPhysicalDeviceProvokingVertexFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceProvokingVertexPropertiesEXT>(VkPhysicalDeviceProvokingVertexPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDevicePushDescriptorPropertiesKHR>(VkPhysicalDevicePushDescriptorPropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT>(VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT>(VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceRayQueryFeaturesKHR>(VkPhysicalDeviceRayQueryFeaturesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV>(VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV>(VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR>(VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV>(VkPhysicalDeviceRayTracingMotionBlurFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceRayTracingPipelineFeaturesKHR>(VkPhysicalDeviceRayTracingPipelineFeaturesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceRayTracingPipelinePropertiesKHR>(VkPhysicalDeviceRayTracingPipelinePropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceRayTracingPropertiesNV>(VkPhysicalDeviceRayTracingPropertiesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV>(VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceRobustness2FeaturesEXT>(VkPhysicalDeviceRobustness2FeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceRobustness2PropertiesEXT>(VkPhysicalDeviceRobustness2PropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceSampleLocationsPropertiesEXT>(VkPhysicalDeviceSampleLocationsPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceSamplerFilterMinmaxProperties>(VkPhysicalDeviceSamplerFilterMinmaxProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceSamplerYcbcrConversionFeatures>(VkPhysicalDeviceSamplerYcbcrConversionFeatures const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceScalarBlockLayoutFeatures>(VkPhysicalDeviceScalarBlockLayoutFeatures const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures>(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT>(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT>(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceShaderAtomicInt64Features>(VkPhysicalDeviceShaderAtomicInt64Features const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceShaderClockFeaturesKHR>(VkPhysicalDeviceShaderClockFeaturesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM>(VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM>(VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceShaderCoreProperties2AMD>(VkPhysicalDeviceShaderCoreProperties2AMD const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceShaderCorePropertiesAMD>(VkPhysicalDeviceShaderCorePropertiesAMD const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures>(VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceShaderDrawParametersFeatures>(VkPhysicalDeviceShaderDrawParametersFeatures const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD>(VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceShaderFloat16Int8Features>(VkPhysicalDeviceShaderFloat16Int8Features const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT>(VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceShaderImageFootprintFeaturesNV>(VkPhysicalDeviceShaderImageFootprintFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceShaderIntegerDotProductFeatures>(VkPhysicalDeviceShaderIntegerDotProductFeatures const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceShaderIntegerDotProductProperties>(VkPhysicalDeviceShaderIntegerDotProductProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>(VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT>(VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT>(VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV>(VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV>(VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures>(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR>(VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceShaderTerminateInvocationFeatures>(VkPhysicalDeviceShaderTerminateInvocationFeatures const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceShadingRateImageFeaturesNV>(VkPhysicalDeviceShadingRateImageFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceShadingRateImagePropertiesNV>(VkPhysicalDeviceShadingRateImagePropertiesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceSparseImageFormatInfo2>(VkPhysicalDeviceSparseImageFormatInfo2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceSparseProperties>(VkPhysicalDeviceSparseProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceSubgroupProperties>(VkPhysicalDeviceSubgroupProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceSubgroupSizeControlFeatures>(VkPhysicalDeviceSubgroupSizeControlFeatures const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceSubgroupSizeControlProperties>(VkPhysicalDeviceSubgroupSizeControlProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT>(VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceSubpassShadingFeaturesHUAWEI>(VkPhysicalDeviceSubpassShadingFeaturesHUAWEI const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceSubpassShadingPropertiesHUAWEI>(VkPhysicalDeviceSubpassShadingPropertiesHUAWEI const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceSurfaceInfo2KHR>(VkPhysicalDeviceSurfaceInfo2KHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT>(VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceSynchronization2Features>(VkPhysicalDeviceSynchronization2Features const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT>(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceTexelBufferAlignmentProperties>(VkPhysicalDeviceTexelBufferAlignmentProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceTextureCompressionASTCHDRFeatures>(VkPhysicalDeviceTextureCompressionASTCHDRFeatures const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceTilePropertiesFeaturesQCOM>(VkPhysicalDeviceTilePropertiesFeaturesQCOM const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceTimelineSemaphoreFeatures>(VkPhysicalDeviceTimelineSemaphoreFeatures const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceTimelineSemaphoreProperties>(VkPhysicalDeviceTimelineSemaphoreProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceToolProperties>(VkPhysicalDeviceToolProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceTransformFeedbackFeaturesEXT>(VkPhysicalDeviceTransformFeedbackFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceTransformFeedbackPropertiesEXT>(VkPhysicalDeviceTransformFeedbackPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceUniformBufferStandardLayoutFeatures>(VkPhysicalDeviceUniformBufferStandardLayoutFeatures const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceVariablePointersFeatures>(VkPhysicalDeviceVariablePointersFeatures const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT>(VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT>(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT>(VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceVideoFormatInfoKHR>(VkPhysicalDeviceVideoFormatInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceVulkan11Features>(VkPhysicalDeviceVulkan11Features const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceVulkan11Properties>(VkPhysicalDeviceVulkan11Properties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceVulkan12Features>(VkPhysicalDeviceVulkan12Features const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceVulkan12Properties>(VkPhysicalDeviceVulkan12Properties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceVulkan13Features>(VkPhysicalDeviceVulkan13Features const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceVulkan13Properties>(VkPhysicalDeviceVulkan13Properties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceVulkanMemoryModelFeatures>(VkPhysicalDeviceVulkanMemoryModelFeatures const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR>(VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT>(VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT>(VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures>(VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineCacheCreateInfo>(VkPipelineCacheCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineCacheHeaderVersionOne>(VkPipelineCacheHeaderVersionOne const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineColorBlendAdvancedStateCreateInfoEXT>(VkPipelineColorBlendAdvancedStateCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineColorBlendAttachmentState>(VkPipelineColorBlendAttachmentState const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineColorBlendStateCreateInfo>(VkPipelineColorBlendStateCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineColorWriteCreateInfoEXT>(VkPipelineColorWriteCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineCompilerControlCreateInfoAMD>(VkPipelineCompilerControlCreateInfoAMD const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineCoverageModulationStateCreateInfoNV>(VkPipelineCoverageModulationStateCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineCoverageReductionStateCreateInfoNV>(VkPipelineCoverageReductionStateCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineCoverageToColorStateCreateInfoNV>(VkPipelineCoverageToColorStateCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineCreationFeedback>(VkPipelineCreationFeedback const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineCreationFeedbackCreateInfo>(VkPipelineCreationFeedbackCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineDepthStencilStateCreateInfo>(VkPipelineDepthStencilStateCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineDiscardRectangleStateCreateInfoEXT>(VkPipelineDiscardRectangleStateCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineDynamicStateCreateInfo>(VkPipelineDynamicStateCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineExecutableInfoKHR>(VkPipelineExecutableInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineExecutableInternalRepresentationKHR>(VkPipelineExecutableInternalRepresentationKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineExecutablePropertiesKHR>(VkPipelineExecutablePropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineExecutableStatisticKHR>(VkPipelineExecutableStatisticKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineFragmentShadingRateEnumStateCreateInfoNV>(VkPipelineFragmentShadingRateEnumStateCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineFragmentShadingRateStateCreateInfoKHR>(VkPipelineFragmentShadingRateStateCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineInfoKHR>(VkPipelineInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineInputAssemblyStateCreateInfo>(VkPipelineInputAssemblyStateCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineLayoutCreateInfo>(VkPipelineLayoutCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineLibraryCreateInfoKHR>(VkPipelineLibraryCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineMultisampleStateCreateInfo>(VkPipelineMultisampleStateCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelinePropertiesIdentifierEXT>(VkPipelinePropertiesIdentifierEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineRasterizationConservativeStateCreateInfoEXT>(VkPipelineRasterizationConservativeStateCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineRasterizationDepthClipStateCreateInfoEXT>(VkPipelineRasterizationDepthClipStateCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineRasterizationLineStateCreateInfoEXT>(VkPipelineRasterizationLineStateCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineRasterizationProvokingVertexStateCreateInfoEXT>(VkPipelineRasterizationProvokingVertexStateCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineRasterizationStateCreateInfo>(VkPipelineRasterizationStateCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineRasterizationStateRasterizationOrderAMD>(VkPipelineRasterizationStateRasterizationOrderAMD const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineRasterizationStateStreamCreateInfoEXT>(VkPipelineRasterizationStateStreamCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineRenderingCreateInfo>(VkPipelineRenderingCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineRepresentativeFragmentTestStateCreateInfoNV>(VkPipelineRepresentativeFragmentTestStateCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineRobustnessCreateInfoEXT>(VkPipelineRobustnessCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineSampleLocationsStateCreateInfoEXT>(VkPipelineSampleLocationsStateCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineShaderStageCreateInfo>(VkPipelineShaderStageCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineShaderStageModuleIdentifierCreateInfoEXT>(VkPipelineShaderStageModuleIdentifierCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineShaderStageRequiredSubgroupSizeCreateInfo>(VkPipelineShaderStageRequiredSubgroupSizeCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineTessellationDomainOriginStateCreateInfo>(VkPipelineTessellationDomainOriginStateCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineTessellationStateCreateInfo>(VkPipelineTessellationStateCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineVertexInputDivisorStateCreateInfoEXT>(VkPipelineVertexInputDivisorStateCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineVertexInputStateCreateInfo>(VkPipelineVertexInputStateCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV>(VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineViewportDepthClipControlCreateInfoEXT>(VkPipelineViewportDepthClipControlCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineViewportExclusiveScissorStateCreateInfoNV>(VkPipelineViewportExclusiveScissorStateCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineViewportShadingRateImageStateCreateInfoNV>(VkPipelineViewportShadingRateImageStateCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineViewportStateCreateInfo>(VkPipelineViewportStateCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineViewportSwizzleStateCreateInfoNV>(VkPipelineViewportSwizzleStateCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPipelineViewportWScalingStateCreateInfoNV>(VkPipelineViewportWScalingStateCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPresentIdKHR>(VkPresentIdKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPresentInfoKHR>(VkPresentInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPresentRegionKHR>(VkPresentRegionKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPresentRegionsKHR>(VkPresentRegionsKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPresentTimeGOOGLE>(VkPresentTimeGOOGLE const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPresentTimesInfoGOOGLE>(VkPresentTimesInfoGOOGLE const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPrivateDataSlotCreateInfo>(VkPrivateDataSlotCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkProtectedSubmitInfo>(VkProtectedSubmitInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkPushConstantRange>(VkPushConstantRange const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkQueryPoolCreateInfo>(VkQueryPoolCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkQueryPoolPerformanceCreateInfoKHR>(VkQueryPoolPerformanceCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkQueryPoolPerformanceQueryCreateInfoINTEL>(VkQueryPoolPerformanceQueryCreateInfoINTEL const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkQueueFamilyCheckpointProperties2NV>(VkQueueFamilyCheckpointProperties2NV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkQueueFamilyCheckpointPropertiesNV>(VkQueueFamilyCheckpointPropertiesNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkQueueFamilyGlobalPriorityPropertiesKHR>(VkQueueFamilyGlobalPriorityPropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkQueueFamilyProperties>(VkQueueFamilyProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkQueueFamilyProperties2>(VkQueueFamilyProperties2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkQueueFamilyQueryResultStatusPropertiesKHR>(VkQueueFamilyQueryResultStatusPropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkQueueFamilyVideoPropertiesKHR>(VkQueueFamilyVideoPropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkRayTracingPipelineCreateInfoKHR>(VkRayTracingPipelineCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkRayTracingPipelineCreateInfoNV>(VkRayTracingPipelineCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkRayTracingPipelineInterfaceCreateInfoKHR>(VkRayTracingPipelineInterfaceCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkRayTracingShaderGroupCreateInfoKHR>(VkRayTracingShaderGroupCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkRayTracingShaderGroupCreateInfoNV>(VkRayTracingShaderGroupCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkRect2D>(VkRect2D const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkRectLayerKHR>(VkRectLayerKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkRefreshCycleDurationGOOGLE>(VkRefreshCycleDurationGOOGLE const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkReleaseSwapchainImagesInfoEXT>(VkReleaseSwapchainImagesInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkRenderPassAttachmentBeginInfo>(VkRenderPassAttachmentBeginInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkRenderPassBeginInfo>(VkRenderPassBeginInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkRenderPassCreateInfo>(VkRenderPassCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkRenderPassCreateInfo2>(VkRenderPassCreateInfo2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkRenderPassCreationControlEXT>(VkRenderPassCreationControlEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkRenderPassCreationFeedbackCreateInfoEXT>(VkRenderPassCreationFeedbackCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkRenderPassCreationFeedbackInfoEXT>(VkRenderPassCreationFeedbackInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkRenderPassFragmentDensityMapCreateInfoEXT>(VkRenderPassFragmentDensityMapCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkRenderPassInputAttachmentAspectCreateInfo>(VkRenderPassInputAttachmentAspectCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkRenderPassMultiviewCreateInfo>(VkRenderPassMultiviewCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkRenderPassSampleLocationsBeginInfoEXT>(VkRenderPassSampleLocationsBeginInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkRenderPassSubpassFeedbackCreateInfoEXT>(VkRenderPassSubpassFeedbackCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkRenderPassSubpassFeedbackInfoEXT>(VkRenderPassSubpassFeedbackInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkRenderPassTransformBeginInfoQCOM>(VkRenderPassTransformBeginInfoQCOM const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkRenderingAttachmentInfo>(VkRenderingAttachmentInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkRenderingFragmentDensityMapAttachmentInfoEXT>(VkRenderingFragmentDensityMapAttachmentInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkRenderingFragmentShadingRateAttachmentInfoKHR>(VkRenderingFragmentShadingRateAttachmentInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkRenderingInfo>(VkRenderingInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkResolveImageInfo2>(VkResolveImageInfo2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSRTDataNV>(VkSRTDataNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSampleLocationEXT>(VkSampleLocationEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSampleLocationsInfoEXT>(VkSampleLocationsInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSamplerBorderColorComponentMappingCreateInfoEXT>(VkSamplerBorderColorComponentMappingCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSamplerCaptureDescriptorDataInfoEXT>(VkSamplerCaptureDescriptorDataInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSamplerCreateInfo>(VkSamplerCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSamplerCustomBorderColorCreateInfoEXT>(VkSamplerCustomBorderColorCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSamplerReductionModeCreateInfo>(VkSamplerReductionModeCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSamplerYcbcrConversionCreateInfo>(VkSamplerYcbcrConversionCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSamplerYcbcrConversionImageFormatProperties>(VkSamplerYcbcrConversionImageFormatProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSamplerYcbcrConversionInfo>(VkSamplerYcbcrConversionInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSemaphoreCreateInfo>(VkSemaphoreCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSemaphoreGetFdInfoKHR>(VkSemaphoreGetFdInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSemaphoreSignalInfo>(VkSemaphoreSignalInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSemaphoreSubmitInfo>(VkSemaphoreSubmitInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSemaphoreTypeCreateInfo>(VkSemaphoreTypeCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSemaphoreWaitInfo>(VkSemaphoreWaitInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSetStateFlagsIndirectCommandNV>(VkSetStateFlagsIndirectCommandNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkShaderModuleCreateInfo>(VkShaderModuleCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkShaderModuleIdentifierEXT>(VkShaderModuleIdentifierEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkShaderModuleValidationCacheCreateInfoEXT>(VkShaderModuleValidationCacheCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkShaderResourceUsageAMD>(VkShaderResourceUsageAMD const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkShaderStatisticsInfoAMD>(VkShaderStatisticsInfoAMD const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkShadingRatePaletteNV>(VkShadingRatePaletteNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSharedPresentSurfaceCapabilitiesKHR>(VkSharedPresentSurfaceCapabilitiesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSparseBufferMemoryBindInfo>(VkSparseBufferMemoryBindInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSparseImageFormatProperties>(VkSparseImageFormatProperties const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSparseImageFormatProperties2>(VkSparseImageFormatProperties2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSparseImageMemoryBind>(VkSparseImageMemoryBind const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSparseImageMemoryBindInfo>(VkSparseImageMemoryBindInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSparseImageMemoryRequirements>(VkSparseImageMemoryRequirements const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSparseImageMemoryRequirements2>(VkSparseImageMemoryRequirements2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSparseImageOpaqueMemoryBindInfo>(VkSparseImageOpaqueMemoryBindInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSparseMemoryBind>(VkSparseMemoryBind const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSpecializationInfo>(VkSpecializationInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSpecializationMapEntry>(VkSpecializationMapEntry const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkStencilOpState>(VkStencilOpState const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkStridedDeviceAddressRegionKHR>(VkStridedDeviceAddressRegionKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSubmitInfo>(VkSubmitInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSubmitInfo2>(VkSubmitInfo2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSubpassBeginInfo>(VkSubpassBeginInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSubpassDependency>(VkSubpassDependency const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSubpassDependency2>(VkSubpassDependency2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSubpassDescription>(VkSubpassDescription const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSubpassDescription2>(VkSubpassDescription2 const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSubpassDescriptionDepthStencilResolve>(VkSubpassDescriptionDepthStencilResolve const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSubpassEndInfo>(VkSubpassEndInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSubpassFragmentDensityMapOffsetEndInfoQCOM>(VkSubpassFragmentDensityMapOffsetEndInfoQCOM const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSubpassResolvePerformanceQueryEXT>(VkSubpassResolvePerformanceQueryEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSubpassSampleLocationsEXT>(VkSubpassSampleLocationsEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSubpassShadingPipelineCreateInfoHUAWEI>(VkSubpassShadingPipelineCreateInfoHUAWEI const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSubresourceLayout>(VkSubresourceLayout const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSubresourceLayout2EXT>(VkSubresourceLayout2EXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSurfaceCapabilities2EXT>(VkSurfaceCapabilities2EXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSurfaceCapabilities2KHR>(VkSurfaceCapabilities2KHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSurfaceCapabilitiesKHR>(VkSurfaceCapabilitiesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSurfaceCapabilitiesPresentBarrierNV>(VkSurfaceCapabilitiesPresentBarrierNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSurfaceFormat2KHR>(VkSurfaceFormat2KHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSurfaceFormatKHR>(VkSurfaceFormatKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSurfacePresentModeCompatibilityEXT>(VkSurfacePresentModeCompatibilityEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSurfacePresentModeEXT>(VkSurfacePresentModeEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSurfacePresentScalingCapabilitiesEXT>(VkSurfacePresentScalingCapabilitiesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSurfaceProtectedCapabilitiesKHR>(VkSurfaceProtectedCapabilitiesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSwapchainCounterCreateInfoEXT>(VkSwapchainCounterCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSwapchainCreateInfoKHR>(VkSwapchainCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSwapchainDisplayNativeHdrCreateInfoAMD>(VkSwapchainDisplayNativeHdrCreateInfoAMD const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSwapchainPresentBarrierCreateInfoNV>(VkSwapchainPresentBarrierCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSwapchainPresentFenceInfoEXT>(VkSwapchainPresentFenceInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSwapchainPresentModeInfoEXT>(VkSwapchainPresentModeInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSwapchainPresentModesCreateInfoEXT>(VkSwapchainPresentModesCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkSwapchainPresentScalingCreateInfoEXT>(VkSwapchainPresentScalingCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkTextureLODGatherFormatPropertiesAMD>(VkTextureLODGatherFormatPropertiesAMD const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkTilePropertiesQCOM>(VkTilePropertiesQCOM const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkTimelineSemaphoreSubmitInfo>(VkTimelineSemaphoreSubmitInfo const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkTraceRaysIndirectCommand2KHR>(VkTraceRaysIndirectCommand2KHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkTraceRaysIndirectCommandKHR>(VkTraceRaysIndirectCommandKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkTransformMatrixKHR>(VkTransformMatrixKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkValidationCacheCreateInfoEXT>(VkValidationCacheCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkValidationFeaturesEXT>(VkValidationFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkValidationFlagsEXT>(VkValidationFlagsEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkVertexInputAttributeDescription>(VkVertexInputAttributeDescription const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkVertexInputAttributeDescription2EXT>(VkVertexInputAttributeDescription2EXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkVertexInputBindingDescription>(VkVertexInputBindingDescription const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkVertexInputBindingDescription2EXT>(VkVertexInputBindingDescription2EXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkVertexInputBindingDivisorDescriptionEXT>(VkVertexInputBindingDivisorDescriptionEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkVideoBeginCodingInfoKHR>(VkVideoBeginCodingInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkVideoCapabilitiesKHR>(VkVideoCapabilitiesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkVideoCodingControlInfoKHR>(VkVideoCodingControlInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkVideoDecodeCapabilitiesKHR>(VkVideoDecodeCapabilitiesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkVideoDecodeInfoKHR>(VkVideoDecodeInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkVideoDecodeUsageInfoKHR>(VkVideoDecodeUsageInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkVideoEncodeCapabilitiesKHR>(VkVideoEncodeCapabilitiesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkVideoEncodeInfoKHR>(VkVideoEncodeInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkVideoEncodeRateControlInfoKHR>(VkVideoEncodeRateControlInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkVideoEncodeRateControlLayerInfoKHR>(VkVideoEncodeRateControlLayerInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkVideoEncodeUsageInfoKHR>(VkVideoEncodeUsageInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkVideoEndCodingInfoKHR>(VkVideoEndCodingInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkVideoFormatPropertiesKHR>(VkVideoFormatPropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkVideoPictureResourceInfoKHR>(VkVideoPictureResourceInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkVideoProfileInfoKHR>(VkVideoProfileInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkVideoProfileListInfoKHR>(VkVideoProfileListInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkVideoReferenceSlotInfoKHR>(VkVideoReferenceSlotInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkVideoSessionCreateInfoKHR>(VkVideoSessionCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkVideoSessionMemoryRequirementsKHR>(VkVideoSessionMemoryRequirementsKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkVideoSessionParametersCreateInfoKHR>(VkVideoSessionParametersCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkVideoSessionParametersUpdateInfoKHR>(VkVideoSessionParametersUpdateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkViewport>(VkViewport const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkViewportSwizzleNV>(VkViewportSwizzleNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkViewportWScalingNV>(VkViewportWScalingNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkWaylandSurfaceCreateInfoKHR>(VkWaylandSurfaceCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkWriteDescriptorSet>(VkWriteDescriptorSet const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkWriteDescriptorSetAccelerationStructureKHR>(VkWriteDescriptorSetAccelerationStructureKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkWriteDescriptorSetAccelerationStructureNV>(VkWriteDescriptorSetAccelerationStructureNV const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkWriteDescriptorSetInlineUniformBlock>(VkWriteDescriptorSetInlineUniformBlock const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkXYColorEXT>(VkXYColorEXT const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkXcbSurfaceCreateInfoKHR>(VkXcbSurfaceCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <> void Print<VkXlibSurfaceCreateInfoKHR>(VkXlibSurfaceCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent );
template <>
inline void Print<VkAabbPositionsKHR>(VkAabbPositionsKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.minX, "float minX", os, indent +1);
    Print(src.minY, "float minY", os, indent +1);
    Print(src.minZ, "float minZ", os, indent +1);
    Print(src.maxX, "float maxX", os, indent +1);
    Print(src.maxY, "float maxY", os, indent +1);
    Print(src.maxZ, "float maxZ", os, indent +1);
}

template <>
inline void Print<VkAccelerationStructureBuildGeometryInfoKHR>(VkAccelerationStructureBuildGeometryInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.type, "VkAccelerationStructureTypeKHR type", os, indent +1);
    Print(src.flags, "VkBuildAccelerationStructureFlagsKHR flags", os, indent +1);
    Print(src.mode, "VkBuildAccelerationStructureModeKHR mode", os, indent +1);
        PrintInterfacePointer(src.srcAccelerationStructure, "VkAccelerationStructureKHR srcAccelerationStructure", os, indent +1);
        PrintInterfacePointer(src.dstAccelerationStructure, "VkAccelerationStructureKHR dstAccelerationStructure", os, indent +1);
    Print(src.geometryCount, "uint32_t geometryCount", os, indent +1);
            if( src.geometryCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to geometryCount" << std::endl;
            } else {
        PrintPointer(src.pGeometries, "const VkAccelerationStructureGeometryKHR * pGeometries", os, indent +1);
            }

            if( src.geometryCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to geometryCount" << std::endl;
            } else {
        PrintPointer(src.ppGeometries, "const VkAccelerationStructureGeometryKHR *const * ppGeometries", os, indent +1);
            }

        // handle union scratchData
}

template <>
inline void Print<VkAccelerationStructureBuildRangeInfoKHR>(VkAccelerationStructureBuildRangeInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.primitiveCount, "uint32_t primitiveCount", os, indent +1);
    Print(src.primitiveOffset, "uint32_t primitiveOffset", os, indent +1);
    Print(src.firstVertex, "uint32_t firstVertex", os, indent +1);
    Print(src.transformOffset, "uint32_t transformOffset", os, indent +1);
}

template <>
inline void Print<VkAccelerationStructureBuildSizesInfoKHR>(VkAccelerationStructureBuildSizesInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.accelerationStructureSize, "VkDeviceSize accelerationStructureSize", os, indent +1);
    Print(src.updateScratchSize, "VkDeviceSize updateScratchSize", os, indent +1);
    Print(src.buildScratchSize, "VkDeviceSize buildScratchSize", os, indent +1);
}

template <>
inline void Print<VkAccelerationStructureCaptureDescriptorDataInfoEXT>(VkAccelerationStructureCaptureDescriptorDataInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.accelerationStructure, "VkAccelerationStructureKHR accelerationStructure", os, indent +1);
        PrintInterfacePointer(src.accelerationStructureNV, "VkAccelerationStructureNV accelerationStructureNV", os, indent +1);
}

template <>
inline void Print<VkAccelerationStructureCreateInfoKHR>(VkAccelerationStructureCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.createFlags, "VkAccelerationStructureCreateFlagsKHR createFlags", os, indent +1);
        PrintInterfacePointer(src.buffer, "VkBuffer buffer", os, indent +1);
    Print(src.offset, "VkDeviceSize offset", os, indent +1);
    Print(src.size, "VkDeviceSize size", os, indent +1);
    Print(src.type, "VkAccelerationStructureTypeKHR type", os, indent +1);
    Print(src.deviceAddress, "VkDeviceAddress deviceAddress", os, indent +1);
}

template <>
inline void Print<VkAccelerationStructureCreateInfoNV>(VkAccelerationStructureCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.compactedSize, "VkDeviceSize compactedSize", os, indent +1);
    Print(src.info, "VkAccelerationStructureInfoNV info", os, indent +1);
}

template <>
inline void Print<VkAccelerationStructureDeviceAddressInfoKHR>(VkAccelerationStructureDeviceAddressInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.accelerationStructure, "VkAccelerationStructureKHR accelerationStructure", os, indent +1);
}

template <>
inline void Print<VkAccelerationStructureGeometryAabbsDataKHR>(VkAccelerationStructureGeometryAabbsDataKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        // handle union data
    Print(src.stride, "VkDeviceSize stride", os, indent +1);
}

template <>
inline void Print<VkAccelerationStructureGeometryInstancesDataKHR>(VkAccelerationStructureGeometryInstancesDataKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.arrayOfPointers, "VkBool32 arrayOfPointers", os, indent +1);
        // handle union data
}

template <>
inline void Print<VkAccelerationStructureGeometryKHR>(VkAccelerationStructureGeometryKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.geometryType, "VkGeometryTypeKHR geometryType", os, indent +1);
        // handle union geometry
    Print(src.flags, "VkGeometryFlagsKHR flags", os, indent +1);
}

template <>
inline void Print<VkAccelerationStructureGeometryMotionTrianglesDataNV>(VkAccelerationStructureGeometryMotionTrianglesDataNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        // handle union vertexData
}

template <>
inline void Print<VkAccelerationStructureGeometryTrianglesDataKHR>(VkAccelerationStructureGeometryTrianglesDataKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.vertexFormat, "VkFormat vertexFormat", os, indent +1);
        // handle union vertexData
    Print(src.vertexStride, "VkDeviceSize vertexStride", os, indent +1);
    Print(src.maxVertex, "uint32_t maxVertex", os, indent +1);
    Print(src.indexType, "VkIndexType indexType", os, indent +1);
        // handle union indexData
        // handle union transformData
}

template <>
inline void Print<VkAccelerationStructureInfoNV>(VkAccelerationStructureInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.type, "VkAccelerationStructureTypeNV type", os, indent +1);
    Print(src.flags, "VkBuildAccelerationStructureFlagsNV flags", os, indent +1);
    Print(src.instanceCount, "uint32_t instanceCount", os, indent +1);
    Print(src.geometryCount, "uint32_t geometryCount", os, indent +1);
            if( src.geometryCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to geometryCount" << std::endl;
            } else {
        PrintPointer(src.pGeometries, "const VkGeometryNV * pGeometries", os, indent +1);
            }

}

template <>
inline void Print<VkAccelerationStructureInstanceKHR>(VkAccelerationStructureInstanceKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.transform, "VkTransformMatrixKHR transform", os, indent +1);
    Print(src.instanceCustomIndex, "uint32_t instanceCustomIndex", os, indent +1);
    Print(src.mask, "uint32_t mask", os, indent +1);
    Print(src.instanceShaderBindingTableRecordOffset, "uint32_t instanceShaderBindingTableRecordOffset", os, indent +1);
    Print(src.flags, "VkGeometryInstanceFlagsKHR flags", os, indent +1);
    Print(src.accelerationStructureReference, "uint64_t accelerationStructureReference", os, indent +1);
}

template <>
inline void Print<VkAccelerationStructureMatrixMotionInstanceNV>(VkAccelerationStructureMatrixMotionInstanceNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.transformT0, "VkTransformMatrixKHR transformT0", os, indent +1);
    Print(src.transformT1, "VkTransformMatrixKHR transformT1", os, indent +1);
    Print(src.instanceCustomIndex, "uint32_t instanceCustomIndex", os, indent +1);
    Print(src.mask, "uint32_t mask", os, indent +1);
    Print(src.instanceShaderBindingTableRecordOffset, "uint32_t instanceShaderBindingTableRecordOffset", os, indent +1);
    Print(src.flags, "VkGeometryInstanceFlagsKHR flags", os, indent +1);
    Print(src.accelerationStructureReference, "uint64_t accelerationStructureReference", os, indent +1);
}

template <>
inline void Print<VkAccelerationStructureMemoryRequirementsInfoNV>(VkAccelerationStructureMemoryRequirementsInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.type, "VkAccelerationStructureMemoryRequirementsTypeNV type", os, indent +1);
        PrintInterfacePointer(src.accelerationStructure, "VkAccelerationStructureNV accelerationStructure", os, indent +1);
}

template <>
inline void Print<VkAccelerationStructureMotionInfoNV>(VkAccelerationStructureMotionInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.maxInstances, "uint32_t maxInstances", os, indent +1);
    Print(src.flags, "VkAccelerationStructureMotionInfoFlagsNV flags", os, indent +1);
}

template <>
inline void Print<VkAccelerationStructureMotionInstanceNV>(VkAccelerationStructureMotionInstanceNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.type, "VkAccelerationStructureMotionInstanceTypeNV type", os, indent +1);
    Print(src.flags, "VkAccelerationStructureMotionInstanceFlagsNV flags", os, indent +1);
        // handle union data
}

template <>
inline void Print<VkAccelerationStructureSRTMotionInstanceNV>(VkAccelerationStructureSRTMotionInstanceNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.transformT0, "VkSRTDataNV transformT0", os, indent +1);
    Print(src.transformT1, "VkSRTDataNV transformT1", os, indent +1);
    Print(src.instanceCustomIndex, "uint32_t instanceCustomIndex", os, indent +1);
    Print(src.mask, "uint32_t mask", os, indent +1);
    Print(src.instanceShaderBindingTableRecordOffset, "uint32_t instanceShaderBindingTableRecordOffset", os, indent +1);
    Print(src.flags, "VkGeometryInstanceFlagsKHR flags", os, indent +1);
    Print(src.accelerationStructureReference, "uint64_t accelerationStructureReference", os, indent +1);
}

template <>
inline void Print<VkAccelerationStructureTrianglesOpacityMicromapEXT>(VkAccelerationStructureTrianglesOpacityMicromapEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.indexType, "VkIndexType indexType", os, indent +1);
        // handle union indexBuffer
    Print(src.indexStride, "VkDeviceSize indexStride", os, indent +1);
    Print(src.baseTriangle, "uint32_t baseTriangle", os, indent +1);
    Print(src.usageCountsCount, "uint32_t usageCountsCount", os, indent +1);
            if( src.usageCountsCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to usageCountsCount" << std::endl;
            } else {
        PrintPointer(src.pUsageCounts, "const VkMicromapUsageEXT * pUsageCounts", os, indent +1);
            }

            if( src.usageCountsCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to usageCountsCount" << std::endl;
            } else {
        PrintPointer(src.ppUsageCounts, "const VkMicromapUsageEXT *const * ppUsageCounts", os, indent +1);
            }

        PrintInterfacePointer(src.micromap, "VkMicromapEXT micromap", os, indent +1);
}

template <>
inline void Print<VkAccelerationStructureVersionInfoKHR>(VkAccelerationStructureVersionInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintPointer(src.pVersionData, "const uint8_t * pVersionData", os, indent +1);
}

template <>
inline void Print<VkAcquireNextImageInfoKHR>(VkAcquireNextImageInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.swapchain, "VkSwapchainKHR swapchain", os, indent +1);
    Print(src.timeout, "uint64_t timeout", os, indent +1);
        PrintInterfacePointer(src.semaphore, "VkSemaphore semaphore", os, indent +1);
        PrintInterfacePointer(src.fence, "VkFence fence", os, indent +1);
    Print(src.deviceMask, "uint32_t deviceMask", os, indent +1);
}

template <>
inline void Print<VkAcquireProfilingLockInfoKHR>(VkAcquireProfilingLockInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkAcquireProfilingLockFlagsKHR flags", os, indent +1);
    Print(src.timeout, "uint64_t timeout", os, indent +1);
}

template <>
inline void Print<VkAllocationCallbacks>(VkAllocationCallbacks const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
        PrintPointer(src.pUserData, "void * pUserData", os, indent +1);
        PrintPointer(src.pfnAllocation, "PFN_vkAllocationFunction pfnAllocation", os, indent +1);
        PrintPointer(src.pfnReallocation, "PFN_vkReallocationFunction pfnReallocation", os, indent +1);
        PrintPointer(src.pfnFree, "PFN_vkFreeFunction pfnFree", os, indent +1);
        PrintPointer(src.pfnInternalAllocation, "PFN_vkInternalAllocationNotification pfnInternalAllocation", os, indent +1);
        PrintPointer(src.pfnInternalFree, "PFN_vkInternalFreeNotification pfnInternalFree", os, indent +1);
}

template <>
inline void Print<VkAmigoProfilingSubmitInfoSEC>(VkAmigoProfilingSubmitInfoSEC const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.firstDrawTimestamp, "uint64_t firstDrawTimestamp", os, indent +1);
    Print(src.swapBufferTimestamp, "uint64_t swapBufferTimestamp", os, indent +1);
}

template <>
inline void Print<VkApplicationInfo>(VkApplicationInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintPointer(src.pApplicationName, "const char * pApplicationName", os, indent +1);
    Print(src.applicationVersion, "uint32_t applicationVersion", os, indent +1);
        PrintPointer(src.pEngineName, "const char * pEngineName", os, indent +1);
    Print(src.engineVersion, "uint32_t engineVersion", os, indent +1);
    Print(src.apiVersion, "uint32_t apiVersion", os, indent +1);
}

template <>
inline void Print<VkAttachmentDescription>(VkAttachmentDescription const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.flags, "VkAttachmentDescriptionFlags flags", os, indent +1);
    Print(src.format, "VkFormat format", os, indent +1);
    Print(src.samples, "VkSampleCountFlagBits samples", os, indent +1);
    Print(src.loadOp, "VkAttachmentLoadOp loadOp", os, indent +1);
    Print(src.storeOp, "VkAttachmentStoreOp storeOp", os, indent +1);
    Print(src.stencilLoadOp, "VkAttachmentLoadOp stencilLoadOp", os, indent +1);
    Print(src.stencilStoreOp, "VkAttachmentStoreOp stencilStoreOp", os, indent +1);
    Print(src.initialLayout, "VkImageLayout initialLayout", os, indent +1);
    Print(src.finalLayout, "VkImageLayout finalLayout", os, indent +1);
}

template <>
inline void Print<VkAttachmentDescription2>(VkAttachmentDescription2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkAttachmentDescriptionFlags flags", os, indent +1);
    Print(src.format, "VkFormat format", os, indent +1);
    Print(src.samples, "VkSampleCountFlagBits samples", os, indent +1);
    Print(src.loadOp, "VkAttachmentLoadOp loadOp", os, indent +1);
    Print(src.storeOp, "VkAttachmentStoreOp storeOp", os, indent +1);
    Print(src.stencilLoadOp, "VkAttachmentLoadOp stencilLoadOp", os, indent +1);
    Print(src.stencilStoreOp, "VkAttachmentStoreOp stencilStoreOp", os, indent +1);
    Print(src.initialLayout, "VkImageLayout initialLayout", os, indent +1);
    Print(src.finalLayout, "VkImageLayout finalLayout", os, indent +1);
}

template <>
inline void Print<VkAttachmentDescriptionStencilLayout>(VkAttachmentDescriptionStencilLayout const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.stencilInitialLayout, "VkImageLayout stencilInitialLayout", os, indent +1);
    Print(src.stencilFinalLayout, "VkImageLayout stencilFinalLayout", os, indent +1);
}

template <>
inline void Print<VkAttachmentReference>(VkAttachmentReference const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.attachment, "uint32_t attachment", os, indent +1);
    Print(src.layout, "VkImageLayout layout", os, indent +1);
}

template <>
inline void Print<VkAttachmentReference2>(VkAttachmentReference2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.attachment, "uint32_t attachment", os, indent +1);
    Print(src.layout, "VkImageLayout layout", os, indent +1);
    Print(src.aspectMask, "VkImageAspectFlags aspectMask", os, indent +1);
}

template <>
inline void Print<VkAttachmentReferenceStencilLayout>(VkAttachmentReferenceStencilLayout const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.stencilLayout, "VkImageLayout stencilLayout", os, indent +1);
}

template <>
inline void Print<VkAttachmentSampleCountInfoAMD>(VkAttachmentSampleCountInfoAMD const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.colorAttachmentCount, "uint32_t colorAttachmentCount", os, indent +1);
            if( src.colorAttachmentCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to colorAttachmentCount" << std::endl;
            } else {
        PrintPointer(src.pColorAttachmentSamples, "const VkSampleCountFlagBits * pColorAttachmentSamples", os, indent +1);
            }

    Print(src.depthStencilAttachmentSamples, "VkSampleCountFlagBits depthStencilAttachmentSamples", os, indent +1);
}

template <>
inline void Print<VkAttachmentSampleLocationsEXT>(VkAttachmentSampleLocationsEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.attachmentIndex, "uint32_t attachmentIndex", os, indent +1);
    Print(src.sampleLocationsInfo, "VkSampleLocationsInfoEXT sampleLocationsInfo", os, indent +1);
}

template <>
inline void Print<VkBaseInStructure>(VkBaseInStructure const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const VkBaseInStructure * pNext", os, indent +1);
}

template <>
inline void Print<VkBaseOutStructure>(VkBaseOutStructure const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "VkBaseOutStructure * pNext", os, indent +1);
}

template <>
inline void Print<VkBindAccelerationStructureMemoryInfoNV>(VkBindAccelerationStructureMemoryInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.accelerationStructure, "VkAccelerationStructureNV accelerationStructure", os, indent +1);
        PrintInterfacePointer(src.memory, "VkDeviceMemory memory", os, indent +1);
    Print(src.memoryOffset, "VkDeviceSize memoryOffset", os, indent +1);
    Print(src.deviceIndexCount, "uint32_t deviceIndexCount", os, indent +1);
            if( src.deviceIndexCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to deviceIndexCount" << std::endl;
            } else {
        PrintPointer(src.pDeviceIndices, "const uint32_t * pDeviceIndices", os, indent +1);
            }

}

template <>
inline void Print<VkBindBufferMemoryDeviceGroupInfo>(VkBindBufferMemoryDeviceGroupInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.deviceIndexCount, "uint32_t deviceIndexCount", os, indent +1);
            if( src.deviceIndexCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to deviceIndexCount" << std::endl;
            } else {
        PrintPointer(src.pDeviceIndices, "const uint32_t * pDeviceIndices", os, indent +1);
            }

}

template <>
inline void Print<VkBindBufferMemoryInfo>(VkBindBufferMemoryInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.buffer, "VkBuffer buffer", os, indent +1);
        PrintInterfacePointer(src.memory, "VkDeviceMemory memory", os, indent +1);
    Print(src.memoryOffset, "VkDeviceSize memoryOffset", os, indent +1);
}

template <>
inline void Print<VkBindImageMemoryDeviceGroupInfo>(VkBindImageMemoryDeviceGroupInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.deviceIndexCount, "uint32_t deviceIndexCount", os, indent +1);
            if( src.deviceIndexCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to deviceIndexCount" << std::endl;
            } else {
        PrintPointer(src.pDeviceIndices, "const uint32_t * pDeviceIndices", os, indent +1);
            }

    Print(src.splitInstanceBindRegionCount, "uint32_t splitInstanceBindRegionCount", os, indent +1);
            if( src.splitInstanceBindRegionCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to splitInstanceBindRegionCount" << std::endl;
            } else {
        PrintPointer(src.pSplitInstanceBindRegions, "const VkRect2D * pSplitInstanceBindRegions", os, indent +1);
            }

}

template <>
inline void Print<VkBindImageMemoryInfo>(VkBindImageMemoryInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.image, "VkImage image", os, indent +1);
        PrintInterfacePointer(src.memory, "VkDeviceMemory memory", os, indent +1);
    Print(src.memoryOffset, "VkDeviceSize memoryOffset", os, indent +1);
}

template <>
inline void Print<VkBindImageMemorySwapchainInfoKHR>(VkBindImageMemorySwapchainInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.swapchain, "VkSwapchainKHR swapchain", os, indent +1);
    Print(src.imageIndex, "uint32_t imageIndex", os, indent +1);
}

template <>
inline void Print<VkBindImagePlaneMemoryInfo>(VkBindImagePlaneMemoryInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.planeAspect, "VkImageAspectFlagBits planeAspect", os, indent +1);
}

template <>
inline void Print<VkBindIndexBufferIndirectCommandNV>(VkBindIndexBufferIndirectCommandNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.bufferAddress, "VkDeviceAddress bufferAddress", os, indent +1);
    Print(src.size, "uint32_t size", os, indent +1);
    Print(src.indexType, "VkIndexType indexType", os, indent +1);
}

template <>
inline void Print<VkBindShaderGroupIndirectCommandNV>(VkBindShaderGroupIndirectCommandNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.groupIndex, "uint32_t groupIndex", os, indent +1);
}

template <>
inline void Print<VkBindSparseInfo>(VkBindSparseInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.waitSemaphoreCount, "uint32_t waitSemaphoreCount", os, indent +1);
            if( src.waitSemaphoreCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to waitSemaphoreCount" << std::endl;
            } else {
        PrintPointer(src.pWaitSemaphores, "const VkSemaphore * pWaitSemaphores", os, indent +1);
            }

    Print(src.bufferBindCount, "uint32_t bufferBindCount", os, indent +1);
            if( src.bufferBindCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to bufferBindCount" << std::endl;
            } else {
        PrintPointer(src.pBufferBinds, "const VkSparseBufferMemoryBindInfo * pBufferBinds", os, indent +1);
            }

    Print(src.imageOpaqueBindCount, "uint32_t imageOpaqueBindCount", os, indent +1);
            if( src.imageOpaqueBindCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to imageOpaqueBindCount" << std::endl;
            } else {
        PrintPointer(src.pImageOpaqueBinds, "const VkSparseImageOpaqueMemoryBindInfo * pImageOpaqueBinds", os, indent +1);
            }

    Print(src.imageBindCount, "uint32_t imageBindCount", os, indent +1);
            if( src.imageBindCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to imageBindCount" << std::endl;
            } else {
        PrintPointer(src.pImageBinds, "const VkSparseImageMemoryBindInfo * pImageBinds", os, indent +1);
            }

    Print(src.signalSemaphoreCount, "uint32_t signalSemaphoreCount", os, indent +1);
            if( src.signalSemaphoreCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to signalSemaphoreCount" << std::endl;
            } else {
        PrintPointer(src.pSignalSemaphores, "const VkSemaphore * pSignalSemaphores", os, indent +1);
            }

}

template <>
inline void Print<VkBindVertexBufferIndirectCommandNV>(VkBindVertexBufferIndirectCommandNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.bufferAddress, "VkDeviceAddress bufferAddress", os, indent +1);
    Print(src.size, "uint32_t size", os, indent +1);
    Print(src.stride, "uint32_t stride", os, indent +1);
}

template <>
inline void Print<VkBindVideoSessionMemoryInfoKHR>(VkBindVideoSessionMemoryInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.memoryBindIndex, "uint32_t memoryBindIndex", os, indent +1);
        PrintInterfacePointer(src.memory, "VkDeviceMemory memory", os, indent +1);
    Print(src.memoryOffset, "VkDeviceSize memoryOffset", os, indent +1);
    Print(src.memorySize, "VkDeviceSize memorySize", os, indent +1);
}

template <>
inline void Print<VkBlitImageInfo2>(VkBlitImageInfo2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.srcImage, "VkImage srcImage", os, indent +1);
    Print(src.srcImageLayout, "VkImageLayout srcImageLayout", os, indent +1);
        PrintInterfacePointer(src.dstImage, "VkImage dstImage", os, indent +1);
    Print(src.dstImageLayout, "VkImageLayout dstImageLayout", os, indent +1);
    Print(src.regionCount, "uint32_t regionCount", os, indent +1);
            if( src.regionCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to regionCount" << std::endl;
            } else {
        PrintPointer(src.pRegions, "const VkImageBlit2 * pRegions", os, indent +1);
            }

    Print(src.filter, "VkFilter filter", os, indent +1);
}

template <>
inline void Print<VkBufferCaptureDescriptorDataInfoEXT>(VkBufferCaptureDescriptorDataInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.buffer, "VkBuffer buffer", os, indent +1);
}

template <>
inline void Print<VkBufferCopy>(VkBufferCopy const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.srcOffset, "VkDeviceSize srcOffset", os, indent +1);
    Print(src.dstOffset, "VkDeviceSize dstOffset", os, indent +1);
    Print(src.size, "VkDeviceSize size", os, indent +1);
}

template <>
inline void Print<VkBufferCopy2>(VkBufferCopy2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.srcOffset, "VkDeviceSize srcOffset", os, indent +1);
    Print(src.dstOffset, "VkDeviceSize dstOffset", os, indent +1);
    Print(src.size, "VkDeviceSize size", os, indent +1);
}

template <>
inline void Print<VkBufferCreateInfo>(VkBufferCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkBufferCreateFlags flags", os, indent +1);
    Print(src.size, "VkDeviceSize size", os, indent +1);
    Print(src.usage, "VkBufferUsageFlags usage", os, indent +1);
    Print(src.sharingMode, "VkSharingMode sharingMode", os, indent +1);
    Print(src.queueFamilyIndexCount, "uint32_t queueFamilyIndexCount", os, indent +1);
            if( src.queueFamilyIndexCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to queueFamilyIndexCount" << std::endl;
            } else {
        PrintPointer(src.pQueueFamilyIndices, "const uint32_t * pQueueFamilyIndices", os, indent +1);
            }

}

template <>
inline void Print<VkBufferDeviceAddressCreateInfoEXT>(VkBufferDeviceAddressCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.deviceAddress, "VkDeviceAddress deviceAddress", os, indent +1);
}

template <>
inline void Print<VkBufferDeviceAddressInfo>(VkBufferDeviceAddressInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.buffer, "VkBuffer buffer", os, indent +1);
}

template <>
inline void Print<VkBufferImageCopy>(VkBufferImageCopy const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.bufferOffset, "VkDeviceSize bufferOffset", os, indent +1);
    Print(src.bufferRowLength, "uint32_t bufferRowLength", os, indent +1);
    Print(src.bufferImageHeight, "uint32_t bufferImageHeight", os, indent +1);
    Print(src.imageSubresource, "VkImageSubresourceLayers imageSubresource", os, indent +1);
    Print(src.imageOffset, "VkOffset3D imageOffset", os, indent +1);
    Print(src.imageExtent, "VkExtent3D imageExtent", os, indent +1);
}

template <>
inline void Print<VkBufferImageCopy2>(VkBufferImageCopy2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.bufferOffset, "VkDeviceSize bufferOffset", os, indent +1);
    Print(src.bufferRowLength, "uint32_t bufferRowLength", os, indent +1);
    Print(src.bufferImageHeight, "uint32_t bufferImageHeight", os, indent +1);
    Print(src.imageSubresource, "VkImageSubresourceLayers imageSubresource", os, indent +1);
    Print(src.imageOffset, "VkOffset3D imageOffset", os, indent +1);
    Print(src.imageExtent, "VkExtent3D imageExtent", os, indent +1);
}

template <>
inline void Print<VkBufferMemoryBarrier>(VkBufferMemoryBarrier const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.srcAccessMask, "VkAccessFlags srcAccessMask", os, indent +1);
    Print(src.dstAccessMask, "VkAccessFlags dstAccessMask", os, indent +1);
    Print(src.srcQueueFamilyIndex, "uint32_t srcQueueFamilyIndex", os, indent +1);
    Print(src.dstQueueFamilyIndex, "uint32_t dstQueueFamilyIndex", os, indent +1);
        PrintInterfacePointer(src.buffer, "VkBuffer buffer", os, indent +1);
    Print(src.offset, "VkDeviceSize offset", os, indent +1);
    Print(src.size, "VkDeviceSize size", os, indent +1);
}

template <>
inline void Print<VkBufferMemoryBarrier2>(VkBufferMemoryBarrier2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.srcStageMask, "VkPipelineStageFlags2 srcStageMask", os, indent +1);
    Print(src.srcAccessMask, "VkAccessFlags2 srcAccessMask", os, indent +1);
    Print(src.dstStageMask, "VkPipelineStageFlags2 dstStageMask", os, indent +1);
    Print(src.dstAccessMask, "VkAccessFlags2 dstAccessMask", os, indent +1);
    Print(src.srcQueueFamilyIndex, "uint32_t srcQueueFamilyIndex", os, indent +1);
    Print(src.dstQueueFamilyIndex, "uint32_t dstQueueFamilyIndex", os, indent +1);
        PrintInterfacePointer(src.buffer, "VkBuffer buffer", os, indent +1);
    Print(src.offset, "VkDeviceSize offset", os, indent +1);
    Print(src.size, "VkDeviceSize size", os, indent +1);
}

template <>
inline void Print<VkBufferMemoryRequirementsInfo2>(VkBufferMemoryRequirementsInfo2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.buffer, "VkBuffer buffer", os, indent +1);
}

template <>
inline void Print<VkBufferOpaqueCaptureAddressCreateInfo>(VkBufferOpaqueCaptureAddressCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.opaqueCaptureAddress, "uint64_t opaqueCaptureAddress", os, indent +1);
}

template <>
inline void Print<VkBufferViewCreateInfo>(VkBufferViewCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkBufferViewCreateFlags flags", os, indent +1);
        PrintInterfacePointer(src.buffer, "VkBuffer buffer", os, indent +1);
    Print(src.format, "VkFormat format", os, indent +1);
    Print(src.offset, "VkDeviceSize offset", os, indent +1);
    Print(src.range, "VkDeviceSize range", os, indent +1);
}

template <>
inline void Print<VkCalibratedTimestampInfoEXT>(VkCalibratedTimestampInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.timeDomain, "VkTimeDomainEXT timeDomain", os, indent +1);
}

template <>
inline void Print<VkCheckpointData2NV>(VkCheckpointData2NV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.stage, "VkPipelineStageFlags2 stage", os, indent +1);
        PrintPointer(src.pCheckpointMarker, "void * pCheckpointMarker", os, indent +1);
}

template <>
inline void Print<VkCheckpointDataNV>(VkCheckpointDataNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.stage, "VkPipelineStageFlagBits stage", os, indent +1);
        PrintPointer(src.pCheckpointMarker, "void * pCheckpointMarker", os, indent +1);
}

template <>
inline void Print<VkClearAttachment>(VkClearAttachment const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.aspectMask, "VkImageAspectFlags aspectMask", os, indent +1);
    Print(src.colorAttachment, "uint32_t colorAttachment", os, indent +1);
        // handle union clearValue
}

template <>
inline void Print<VkClearDepthStencilValue>(VkClearDepthStencilValue const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.depth, "float depth", os, indent +1);
    Print(src.stencil, "uint32_t stencil", os, indent +1);
}

template <>
inline void Print<VkClearRect>(VkClearRect const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.rect, "VkRect2D rect", os, indent +1);
    Print(src.baseArrayLayer, "uint32_t baseArrayLayer", os, indent +1);
    Print(src.layerCount, "uint32_t layerCount", os, indent +1);
}

template <>
inline void Print<VkCoarseSampleLocationNV>(VkCoarseSampleLocationNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.pixelX, "uint32_t pixelX", os, indent +1);
    Print(src.pixelY, "uint32_t pixelY", os, indent +1);
    Print(src.sample, "uint32_t sample", os, indent +1);
}

template <>
inline void Print<VkCoarseSampleOrderCustomNV>(VkCoarseSampleOrderCustomNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.shadingRate, "VkShadingRatePaletteEntryNV shadingRate", os, indent +1);
    Print(src.sampleCount, "uint32_t sampleCount", os, indent +1);
    Print(src.sampleLocationCount, "uint32_t sampleLocationCount", os, indent +1);
            if( src.sampleLocationCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to sampleLocationCount" << std::endl;
            } else {
        PrintPointer(src.pSampleLocations, "const VkCoarseSampleLocationNV * pSampleLocations", os, indent +1);
            }

}

template <>
inline void Print<VkColorBlendAdvancedEXT>(VkColorBlendAdvancedEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.advancedBlendOp, "VkBlendOp advancedBlendOp", os, indent +1);
    Print(src.srcPremultiplied, "VkBool32 srcPremultiplied", os, indent +1);
    Print(src.dstPremultiplied, "VkBool32 dstPremultiplied", os, indent +1);
    Print(src.blendOverlap, "VkBlendOverlapEXT blendOverlap", os, indent +1);
    Print(src.clampResults, "VkBool32 clampResults", os, indent +1);
}

template <>
inline void Print<VkColorBlendEquationEXT>(VkColorBlendEquationEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.srcColorBlendFactor, "VkBlendFactor srcColorBlendFactor", os, indent +1);
    Print(src.dstColorBlendFactor, "VkBlendFactor dstColorBlendFactor", os, indent +1);
    Print(src.colorBlendOp, "VkBlendOp colorBlendOp", os, indent +1);
    Print(src.srcAlphaBlendFactor, "VkBlendFactor srcAlphaBlendFactor", os, indent +1);
    Print(src.dstAlphaBlendFactor, "VkBlendFactor dstAlphaBlendFactor", os, indent +1);
    Print(src.alphaBlendOp, "VkBlendOp alphaBlendOp", os, indent +1);
}

template <>
inline void Print<VkCommandBufferAllocateInfo>(VkCommandBufferAllocateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.commandPool, "VkCommandPool commandPool", os, indent +1);
    Print(src.level, "VkCommandBufferLevel level", os, indent +1);
    Print(src.commandBufferCount, "uint32_t commandBufferCount", os, indent +1);
}

template <>
inline void Print<VkCommandBufferBeginInfo>(VkCommandBufferBeginInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkCommandBufferUsageFlags flags", os, indent +1);
        PrintPointer(src.pInheritanceInfo, "const VkCommandBufferInheritanceInfo * pInheritanceInfo", os, indent +1);
}

template <>
inline void Print<VkCommandBufferInheritanceConditionalRenderingInfoEXT>(VkCommandBufferInheritanceConditionalRenderingInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.conditionalRenderingEnable, "VkBool32 conditionalRenderingEnable", os, indent +1);
}

template <>
inline void Print<VkCommandBufferInheritanceInfo>(VkCommandBufferInheritanceInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.renderPass, "VkRenderPass renderPass", os, indent +1);
    Print(src.subpass, "uint32_t subpass", os, indent +1);
        PrintInterfacePointer(src.framebuffer, "VkFramebuffer framebuffer", os, indent +1);
    Print(src.occlusionQueryEnable, "VkBool32 occlusionQueryEnable", os, indent +1);
    Print(src.queryFlags, "VkQueryControlFlags queryFlags", os, indent +1);
    Print(src.pipelineStatistics, "VkQueryPipelineStatisticFlags pipelineStatistics", os, indent +1);
}

template <>
inline void Print<VkCommandBufferInheritanceRenderPassTransformInfoQCOM>(VkCommandBufferInheritanceRenderPassTransformInfoQCOM const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.transform, "VkSurfaceTransformFlagBitsKHR transform", os, indent +1);
    Print(src.renderArea, "VkRect2D renderArea", os, indent +1);
}

template <>
inline void Print<VkCommandBufferInheritanceRenderingInfo>(VkCommandBufferInheritanceRenderingInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkRenderingFlags flags", os, indent +1);
    Print(src.viewMask, "uint32_t viewMask", os, indent +1);
    Print(src.colorAttachmentCount, "uint32_t colorAttachmentCount", os, indent +1);
            if( src.colorAttachmentCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to colorAttachmentCount" << std::endl;
            } else {
        PrintPointer(src.pColorAttachmentFormats, "const VkFormat * pColorAttachmentFormats", os, indent +1);
            }

    Print(src.depthAttachmentFormat, "VkFormat depthAttachmentFormat", os, indent +1);
    Print(src.stencilAttachmentFormat, "VkFormat stencilAttachmentFormat", os, indent +1);
    Print(src.rasterizationSamples, "VkSampleCountFlagBits rasterizationSamples", os, indent +1);
}

template <>
inline void Print<VkCommandBufferInheritanceViewportScissorInfoNV>(VkCommandBufferInheritanceViewportScissorInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.viewportScissor2D, "VkBool32 viewportScissor2D", os, indent +1);
    Print(src.viewportDepthCount, "uint32_t viewportDepthCount", os, indent +1);
        PrintPointer(src.pViewportDepths, "const VkViewport * pViewportDepths", os, indent +1);
}

template <>
inline void Print<VkCommandBufferSubmitInfo>(VkCommandBufferSubmitInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.commandBuffer, "VkCommandBuffer commandBuffer", os, indent +1);
    Print(src.deviceMask, "uint32_t deviceMask", os, indent +1);
}

template <>
inline void Print<VkCommandPoolCreateInfo>(VkCommandPoolCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkCommandPoolCreateFlags flags", os, indent +1);
    Print(src.queueFamilyIndex, "uint32_t queueFamilyIndex", os, indent +1);
}

template <>
inline void Print<VkComponentMapping>(VkComponentMapping const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.r, "VkComponentSwizzle r", os, indent +1);
    Print(src.g, "VkComponentSwizzle g", os, indent +1);
    Print(src.b, "VkComponentSwizzle b", os, indent +1);
    Print(src.a, "VkComponentSwizzle a", os, indent +1);
}

template <>
inline void Print<VkComputePipelineCreateInfo>(VkComputePipelineCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkPipelineCreateFlags flags", os, indent +1);
    Print(src.stage, "VkPipelineShaderStageCreateInfo stage", os, indent +1);
        PrintInterfacePointer(src.layout, "VkPipelineLayout layout", os, indent +1);
        PrintInterfacePointer(src.basePipelineHandle, "VkPipeline basePipelineHandle", os, indent +1);
    Print(src.basePipelineIndex, "int32_t basePipelineIndex", os, indent +1);
}

template <>
inline void Print<VkConditionalRenderingBeginInfoEXT>(VkConditionalRenderingBeginInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.buffer, "VkBuffer buffer", os, indent +1);
    Print(src.offset, "VkDeviceSize offset", os, indent +1);
    Print(src.flags, "VkConditionalRenderingFlagsEXT flags", os, indent +1);
}

template <>
inline void Print<VkConformanceVersion>(VkConformanceVersion const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.major, "uint8_t major", os, indent +1);
    Print(src.minor, "uint8_t minor", os, indent +1);
    Print(src.subminor, "uint8_t subminor", os, indent +1);
    Print(src.patch, "uint8_t patch", os, indent +1);
}

template <>
inline void Print<VkCooperativeMatrixPropertiesNV>(VkCooperativeMatrixPropertiesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.MSize, "uint32_t MSize", os, indent +1);
    Print(src.NSize, "uint32_t NSize", os, indent +1);
    Print(src.KSize, "uint32_t KSize", os, indent +1);
    Print(src.AType, "VkComponentTypeNV AType", os, indent +1);
    Print(src.BType, "VkComponentTypeNV BType", os, indent +1);
    Print(src.CType, "VkComponentTypeNV CType", os, indent +1);
    Print(src.DType, "VkComponentTypeNV DType", os, indent +1);
    Print(src.scope, "VkScopeNV scope", os, indent +1);
}

template <>
inline void Print<VkCopyAccelerationStructureInfoKHR>(VkCopyAccelerationStructureInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.src, "VkAccelerationStructureKHR src", os, indent +1);
        PrintInterfacePointer(src.dst, "VkAccelerationStructureKHR dst", os, indent +1);
    Print(src.mode, "VkCopyAccelerationStructureModeKHR mode", os, indent +1);
}

template <>
inline void Print<VkCopyAccelerationStructureToMemoryInfoKHR>(VkCopyAccelerationStructureToMemoryInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.src, "VkAccelerationStructureKHR src", os, indent +1);
        // handle union dst
    Print(src.mode, "VkCopyAccelerationStructureModeKHR mode", os, indent +1);
}

template <>
inline void Print<VkCopyBufferInfo2>(VkCopyBufferInfo2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.srcBuffer, "VkBuffer srcBuffer", os, indent +1);
        PrintInterfacePointer(src.dstBuffer, "VkBuffer dstBuffer", os, indent +1);
    Print(src.regionCount, "uint32_t regionCount", os, indent +1);
            if( src.regionCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to regionCount" << std::endl;
            } else {
        PrintPointer(src.pRegions, "const VkBufferCopy2 * pRegions", os, indent +1);
            }

}

template <>
inline void Print<VkCopyBufferToImageInfo2>(VkCopyBufferToImageInfo2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.srcBuffer, "VkBuffer srcBuffer", os, indent +1);
        PrintInterfacePointer(src.dstImage, "VkImage dstImage", os, indent +1);
    Print(src.dstImageLayout, "VkImageLayout dstImageLayout", os, indent +1);
    Print(src.regionCount, "uint32_t regionCount", os, indent +1);
            if( src.regionCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to regionCount" << std::endl;
            } else {
        PrintPointer(src.pRegions, "const VkBufferImageCopy2 * pRegions", os, indent +1);
            }

}

template <>
inline void Print<VkCopyCommandTransformInfoQCOM>(VkCopyCommandTransformInfoQCOM const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.transform, "VkSurfaceTransformFlagBitsKHR transform", os, indent +1);
}

template <>
inline void Print<VkCopyDescriptorSet>(VkCopyDescriptorSet const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.srcSet, "VkDescriptorSet srcSet", os, indent +1);
    Print(src.srcBinding, "uint32_t srcBinding", os, indent +1);
    Print(src.srcArrayElement, "uint32_t srcArrayElement", os, indent +1);
        PrintInterfacePointer(src.dstSet, "VkDescriptorSet dstSet", os, indent +1);
    Print(src.dstBinding, "uint32_t dstBinding", os, indent +1);
    Print(src.dstArrayElement, "uint32_t dstArrayElement", os, indent +1);
    Print(src.descriptorCount, "uint32_t descriptorCount", os, indent +1);
}

template <>
inline void Print<VkCopyImageInfo2>(VkCopyImageInfo2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.srcImage, "VkImage srcImage", os, indent +1);
    Print(src.srcImageLayout, "VkImageLayout srcImageLayout", os, indent +1);
        PrintInterfacePointer(src.dstImage, "VkImage dstImage", os, indent +1);
    Print(src.dstImageLayout, "VkImageLayout dstImageLayout", os, indent +1);
    Print(src.regionCount, "uint32_t regionCount", os, indent +1);
            if( src.regionCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to regionCount" << std::endl;
            } else {
        PrintPointer(src.pRegions, "const VkImageCopy2 * pRegions", os, indent +1);
            }

}

template <>
inline void Print<VkCopyImageToBufferInfo2>(VkCopyImageToBufferInfo2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.srcImage, "VkImage srcImage", os, indent +1);
    Print(src.srcImageLayout, "VkImageLayout srcImageLayout", os, indent +1);
        PrintInterfacePointer(src.dstBuffer, "VkBuffer dstBuffer", os, indent +1);
    Print(src.regionCount, "uint32_t regionCount", os, indent +1);
            if( src.regionCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to regionCount" << std::endl;
            } else {
        PrintPointer(src.pRegions, "const VkBufferImageCopy2 * pRegions", os, indent +1);
            }

}

template <>
inline void Print<VkCopyMemoryIndirectCommandNV>(VkCopyMemoryIndirectCommandNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.srcAddress, "VkDeviceAddress srcAddress", os, indent +1);
    Print(src.dstAddress, "VkDeviceAddress dstAddress", os, indent +1);
    Print(src.size, "VkDeviceSize size", os, indent +1);
}

template <>
inline void Print<VkCopyMemoryToAccelerationStructureInfoKHR>(VkCopyMemoryToAccelerationStructureInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        // handle union src
        PrintInterfacePointer(src.dst, "VkAccelerationStructureKHR dst", os, indent +1);
    Print(src.mode, "VkCopyAccelerationStructureModeKHR mode", os, indent +1);
}

template <>
inline void Print<VkCopyMemoryToImageIndirectCommandNV>(VkCopyMemoryToImageIndirectCommandNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.srcAddress, "VkDeviceAddress srcAddress", os, indent +1);
    Print(src.bufferRowLength, "uint32_t bufferRowLength", os, indent +1);
    Print(src.bufferImageHeight, "uint32_t bufferImageHeight", os, indent +1);
    Print(src.imageSubresource, "VkImageSubresourceLayers imageSubresource", os, indent +1);
    Print(src.imageOffset, "VkOffset3D imageOffset", os, indent +1);
    Print(src.imageExtent, "VkExtent3D imageExtent", os, indent +1);
}

template <>
inline void Print<VkCopyMemoryToMicromapInfoEXT>(VkCopyMemoryToMicromapInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        // handle union src
        PrintInterfacePointer(src.dst, "VkMicromapEXT dst", os, indent +1);
    Print(src.mode, "VkCopyMicromapModeEXT mode", os, indent +1);
}

template <>
inline void Print<VkCopyMicromapInfoEXT>(VkCopyMicromapInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.src, "VkMicromapEXT src", os, indent +1);
        PrintInterfacePointer(src.dst, "VkMicromapEXT dst", os, indent +1);
    Print(src.mode, "VkCopyMicromapModeEXT mode", os, indent +1);
}

template <>
inline void Print<VkCopyMicromapToMemoryInfoEXT>(VkCopyMicromapToMemoryInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.src, "VkMicromapEXT src", os, indent +1);
        // handle union dst
    Print(src.mode, "VkCopyMicromapModeEXT mode", os, indent +1);
}

template <>
inline void Print<VkCuFunctionCreateInfoNVX>(VkCuFunctionCreateInfoNVX const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.module, "VkCuModuleNVX module", os, indent +1);
        PrintPointer(src.pName, "const char * pName", os, indent +1);
}

template <>
inline void Print<VkCuLaunchInfoNVX>(VkCuLaunchInfoNVX const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.function, "VkCuFunctionNVX function", os, indent +1);
    Print(src.gridDimX, "uint32_t gridDimX", os, indent +1);
    Print(src.gridDimY, "uint32_t gridDimY", os, indent +1);
    Print(src.gridDimZ, "uint32_t gridDimZ", os, indent +1);
    Print(src.blockDimX, "uint32_t blockDimX", os, indent +1);
    Print(src.blockDimY, "uint32_t blockDimY", os, indent +1);
    Print(src.blockDimZ, "uint32_t blockDimZ", os, indent +1);
    Print(src.sharedMemBytes, "uint32_t sharedMemBytes", os, indent +1);
    Print(src.paramCount, "size_t paramCount", os, indent +1);
            if( src.paramCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to paramCount" << std::endl;
            } else {
        PrintPointer(src.pParams, "const void *const * pParams", os, indent +1);
            }

    Print(src.extraCount, "size_t extraCount", os, indent +1);
            if( src.extraCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to extraCount" << std::endl;
            } else {
        PrintPointer(src.pExtras, "const void *const * pExtras", os, indent +1);
            }

}

template <>
inline void Print<VkCuModuleCreateInfoNVX>(VkCuModuleCreateInfoNVX const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.dataSize, "size_t dataSize", os, indent +1);
            if( src.dataSize == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to dataSize" << std::endl;
            } else {
        PrintPointer(src.pData, "const void * pData", os, indent +1);
            }

}

template <>
inline void Print<VkDebugMarkerMarkerInfoEXT>(VkDebugMarkerMarkerInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintPointer(src.pMarkerName, "const char * pMarkerName", os, indent +1);
    PrintArray(src.color, 4, "float [4] color", os, indent + 1);
}

template <>
inline void Print<VkDebugMarkerObjectNameInfoEXT>(VkDebugMarkerObjectNameInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.objectType, "VkDebugReportObjectTypeEXT objectType", os, indent +1);
    Print(src.object, "uint64_t object", os, indent +1);
        PrintPointer(src.pObjectName, "const char * pObjectName", os, indent +1);
}

template <>
inline void Print<VkDebugMarkerObjectTagInfoEXT>(VkDebugMarkerObjectTagInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.objectType, "VkDebugReportObjectTypeEXT objectType", os, indent +1);
    Print(src.object, "uint64_t object", os, indent +1);
    Print(src.tagName, "uint64_t tagName", os, indent +1);
    Print(src.tagSize, "size_t tagSize", os, indent +1);
            if( src.tagSize == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to tagSize" << std::endl;
            } else {
        PrintPointer(src.pTag, "const void * pTag", os, indent +1);
            }

}

template <>
inline void Print<VkDebugReportCallbackCreateInfoEXT>(VkDebugReportCallbackCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkDebugReportFlagsEXT flags", os, indent +1);
        PrintPointer(src.pfnCallback, "PFN_vkDebugReportCallbackEXT pfnCallback", os, indent +1);
        PrintPointer(src.pUserData, "void * pUserData", os, indent +1);
}

template <>
inline void Print<VkDebugUtilsLabelEXT>(VkDebugUtilsLabelEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintPointer(src.pLabelName, "const char * pLabelName", os, indent +1);
    PrintArray(src.color, 4, "float [4] color", os, indent + 1);
}

template <>
inline void Print<VkDebugUtilsMessengerCallbackDataEXT>(VkDebugUtilsMessengerCallbackDataEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkDebugUtilsMessengerCallbackDataFlagsEXT flags", os, indent +1);
        PrintPointer(src.pMessageIdName, "const char * pMessageIdName", os, indent +1);
    Print(src.messageIdNumber, "int32_t messageIdNumber", os, indent +1);
        PrintPointer(src.pMessage, "const char * pMessage", os, indent +1);
    Print(src.queueLabelCount, "uint32_t queueLabelCount", os, indent +1);
            if( src.queueLabelCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to queueLabelCount" << std::endl;
            } else {
        PrintPointer(src.pQueueLabels, "const VkDebugUtilsLabelEXT * pQueueLabels", os, indent +1);
            }

    Print(src.cmdBufLabelCount, "uint32_t cmdBufLabelCount", os, indent +1);
            if( src.cmdBufLabelCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to cmdBufLabelCount" << std::endl;
            } else {
        PrintPointer(src.pCmdBufLabels, "const VkDebugUtilsLabelEXT * pCmdBufLabels", os, indent +1);
            }

    Print(src.objectCount, "uint32_t objectCount", os, indent +1);
            if( src.objectCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to objectCount" << std::endl;
            } else {
        PrintPointer(src.pObjects, "const VkDebugUtilsObjectNameInfoEXT * pObjects", os, indent +1);
            }

}

template <>
inline void Print<VkDebugUtilsMessengerCreateInfoEXT>(VkDebugUtilsMessengerCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkDebugUtilsMessengerCreateFlagsEXT flags", os, indent +1);
    Print(src.messageSeverity, "VkDebugUtilsMessageSeverityFlagsEXT messageSeverity", os, indent +1);
    Print(src.messageType, "VkDebugUtilsMessageTypeFlagsEXT messageType", os, indent +1);
        PrintPointer(src.pfnUserCallback, "PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback", os, indent +1);
        PrintPointer(src.pUserData, "void * pUserData", os, indent +1);
}

template <>
inline void Print<VkDebugUtilsObjectNameInfoEXT>(VkDebugUtilsObjectNameInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.objectType, "VkObjectType objectType", os, indent +1);
    Print(src.objectHandle, "uint64_t objectHandle", os, indent +1);
        PrintPointer(src.pObjectName, "const char * pObjectName", os, indent +1);
}

template <>
inline void Print<VkDebugUtilsObjectTagInfoEXT>(VkDebugUtilsObjectTagInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.objectType, "VkObjectType objectType", os, indent +1);
    Print(src.objectHandle, "uint64_t objectHandle", os, indent +1);
    Print(src.tagName, "uint64_t tagName", os, indent +1);
    Print(src.tagSize, "size_t tagSize", os, indent +1);
            if( src.tagSize == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to tagSize" << std::endl;
            } else {
        PrintPointer(src.pTag, "const void * pTag", os, indent +1);
            }

}

template <>
inline void Print<VkDecompressMemoryRegionNV>(VkDecompressMemoryRegionNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.srcAddress, "VkDeviceAddress srcAddress", os, indent +1);
    Print(src.dstAddress, "VkDeviceAddress dstAddress", os, indent +1);
    Print(src.compressedSize, "VkDeviceSize compressedSize", os, indent +1);
    Print(src.decompressedSize, "VkDeviceSize decompressedSize", os, indent +1);
    Print(src.decompressionMethod, "VkMemoryDecompressionMethodFlagsNV decompressionMethod", os, indent +1);
}

template <>
inline void Print<VkDedicatedAllocationBufferCreateInfoNV>(VkDedicatedAllocationBufferCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.dedicatedAllocation, "VkBool32 dedicatedAllocation", os, indent +1);
}

template <>
inline void Print<VkDedicatedAllocationImageCreateInfoNV>(VkDedicatedAllocationImageCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.dedicatedAllocation, "VkBool32 dedicatedAllocation", os, indent +1);
}

template <>
inline void Print<VkDedicatedAllocationMemoryAllocateInfoNV>(VkDedicatedAllocationMemoryAllocateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.image, "VkImage image", os, indent +1);
        PrintInterfacePointer(src.buffer, "VkBuffer buffer", os, indent +1);
}

template <>
inline void Print<VkDependencyInfo>(VkDependencyInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.dependencyFlags, "VkDependencyFlags dependencyFlags", os, indent +1);
    Print(src.memoryBarrierCount, "uint32_t memoryBarrierCount", os, indent +1);
            if( src.memoryBarrierCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to memoryBarrierCount" << std::endl;
            } else {
        PrintPointer(src.pMemoryBarriers, "const VkMemoryBarrier2 * pMemoryBarriers", os, indent +1);
            }

    Print(src.bufferMemoryBarrierCount, "uint32_t bufferMemoryBarrierCount", os, indent +1);
            if( src.bufferMemoryBarrierCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to bufferMemoryBarrierCount" << std::endl;
            } else {
        PrintPointer(src.pBufferMemoryBarriers, "const VkBufferMemoryBarrier2 * pBufferMemoryBarriers", os, indent +1);
            }

    Print(src.imageMemoryBarrierCount, "uint32_t imageMemoryBarrierCount", os, indent +1);
            if( src.imageMemoryBarrierCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to imageMemoryBarrierCount" << std::endl;
            } else {
        PrintPointer(src.pImageMemoryBarriers, "const VkImageMemoryBarrier2 * pImageMemoryBarriers", os, indent +1);
            }

}

template <>
inline void Print<VkDescriptorAddressInfoEXT>(VkDescriptorAddressInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.address, "VkDeviceAddress address", os, indent +1);
    Print(src.range, "VkDeviceSize range", os, indent +1);
    Print(src.format, "VkFormat format", os, indent +1);
}

template <>
inline void Print<VkDescriptorBufferBindingInfoEXT>(VkDescriptorBufferBindingInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.address, "VkDeviceAddress address", os, indent +1);
    Print(src.usage, "VkBufferUsageFlags usage", os, indent +1);
}

template <>
inline void Print<VkDescriptorBufferBindingPushDescriptorBufferHandleEXT>(VkDescriptorBufferBindingPushDescriptorBufferHandleEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
        PrintInterfacePointer(src.buffer, "VkBuffer buffer", os, indent +1);
}

template <>
inline void Print<VkDescriptorBufferInfo>(VkDescriptorBufferInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
        PrintInterfacePointer(src.buffer, "VkBuffer buffer", os, indent +1);
    Print(src.offset, "VkDeviceSize offset", os, indent +1);
    Print(src.range, "VkDeviceSize range", os, indent +1);
}

template <>
inline void Print<VkDescriptorGetInfoEXT>(VkDescriptorGetInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.type, "VkDescriptorType type", os, indent +1);
        // handle union data
}

template <>
inline void Print<VkDescriptorImageInfo>(VkDescriptorImageInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
        PrintInterfacePointer(src.sampler, "VkSampler sampler", os, indent +1);
        PrintInterfacePointer(src.imageView, "VkImageView imageView", os, indent +1);
    Print(src.imageLayout, "VkImageLayout imageLayout", os, indent +1);
}

template <>
inline void Print<VkDescriptorPoolCreateInfo>(VkDescriptorPoolCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkDescriptorPoolCreateFlags flags", os, indent +1);
    Print(src.maxSets, "uint32_t maxSets", os, indent +1);
    Print(src.poolSizeCount, "uint32_t poolSizeCount", os, indent +1);
            if( src.poolSizeCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to poolSizeCount" << std::endl;
            } else {
        PrintPointer(src.pPoolSizes, "const VkDescriptorPoolSize * pPoolSizes", os, indent +1);
            }

}

template <>
inline void Print<VkDescriptorPoolInlineUniformBlockCreateInfo>(VkDescriptorPoolInlineUniformBlockCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.maxInlineUniformBlockBindings, "uint32_t maxInlineUniformBlockBindings", os, indent +1);
}

template <>
inline void Print<VkDescriptorPoolSize>(VkDescriptorPoolSize const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.type, "VkDescriptorType type", os, indent +1);
    Print(src.descriptorCount, "uint32_t descriptorCount", os, indent +1);
}

template <>
inline void Print<VkDescriptorSetAllocateInfo>(VkDescriptorSetAllocateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.descriptorPool, "VkDescriptorPool descriptorPool", os, indent +1);
    Print(src.descriptorSetCount, "uint32_t descriptorSetCount", os, indent +1);
            if( src.descriptorSetCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to descriptorSetCount" << std::endl;
            } else {
        PrintPointer(src.pSetLayouts, "const VkDescriptorSetLayout * pSetLayouts", os, indent +1);
            }

}

template <>
inline void Print<VkDescriptorSetBindingReferenceVALVE>(VkDescriptorSetBindingReferenceVALVE const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.descriptorSetLayout, "VkDescriptorSetLayout descriptorSetLayout", os, indent +1);
    Print(src.binding, "uint32_t binding", os, indent +1);
}

template <>
inline void Print<VkDescriptorSetLayoutBinding>(VkDescriptorSetLayoutBinding const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.binding, "uint32_t binding", os, indent +1);
    Print(src.descriptorType, "VkDescriptorType descriptorType", os, indent +1);
    Print(src.descriptorCount, "uint32_t descriptorCount", os, indent +1);
    Print(src.stageFlags, "VkShaderStageFlags stageFlags", os, indent +1);
            if( src.descriptorCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to descriptorCount" << std::endl;
            } else {
        PrintPointer(src.pImmutableSamplers, "const VkSampler * pImmutableSamplers", os, indent +1);
            }

}

template <>
inline void Print<VkDescriptorSetLayoutBindingFlagsCreateInfo>(VkDescriptorSetLayoutBindingFlagsCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.bindingCount, "uint32_t bindingCount", os, indent +1);
            if( src.bindingCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to bindingCount" << std::endl;
            } else {
        PrintPointer(src.pBindingFlags, "const VkDescriptorBindingFlags * pBindingFlags", os, indent +1);
            }

}

template <>
inline void Print<VkDescriptorSetLayoutCreateInfo>(VkDescriptorSetLayoutCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkDescriptorSetLayoutCreateFlags flags", os, indent +1);
    Print(src.bindingCount, "uint32_t bindingCount", os, indent +1);
            if( src.bindingCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to bindingCount" << std::endl;
            } else {
        PrintPointer(src.pBindings, "const VkDescriptorSetLayoutBinding * pBindings", os, indent +1);
            }

}

template <>
inline void Print<VkDescriptorSetLayoutHostMappingInfoVALVE>(VkDescriptorSetLayoutHostMappingInfoVALVE const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.descriptorOffset, "size_t descriptorOffset", os, indent +1);
    Print(src.descriptorSize, "uint32_t descriptorSize", os, indent +1);
}

template <>
inline void Print<VkDescriptorSetLayoutSupport>(VkDescriptorSetLayoutSupport const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.supported, "VkBool32 supported", os, indent +1);
}

template <>
inline void Print<VkDescriptorSetVariableDescriptorCountAllocateInfo>(VkDescriptorSetVariableDescriptorCountAllocateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.descriptorSetCount, "uint32_t descriptorSetCount", os, indent +1);
            if( src.descriptorSetCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to descriptorSetCount" << std::endl;
            } else {
        PrintPointer(src.pDescriptorCounts, "const uint32_t * pDescriptorCounts", os, indent +1);
            }

}

template <>
inline void Print<VkDescriptorSetVariableDescriptorCountLayoutSupport>(VkDescriptorSetVariableDescriptorCountLayoutSupport const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.maxVariableDescriptorCount, "uint32_t maxVariableDescriptorCount", os, indent +1);
}

template <>
inline void Print<VkDescriptorUpdateTemplateCreateInfo>(VkDescriptorUpdateTemplateCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkDescriptorUpdateTemplateCreateFlags flags", os, indent +1);
    Print(src.descriptorUpdateEntryCount, "uint32_t descriptorUpdateEntryCount", os, indent +1);
            if( src.descriptorUpdateEntryCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to descriptorUpdateEntryCount" << std::endl;
            } else {
        PrintPointer(src.pDescriptorUpdateEntries, "const VkDescriptorUpdateTemplateEntry * pDescriptorUpdateEntries", os, indent +1);
            }

    Print(src.templateType, "VkDescriptorUpdateTemplateType templateType", os, indent +1);
        PrintInterfacePointer(src.descriptorSetLayout, "VkDescriptorSetLayout descriptorSetLayout", os, indent +1);
    Print(src.pipelineBindPoint, "VkPipelineBindPoint pipelineBindPoint", os, indent +1);
        PrintInterfacePointer(src.pipelineLayout, "VkPipelineLayout pipelineLayout", os, indent +1);
    Print(src.set, "uint32_t set", os, indent +1);
}

template <>
inline void Print<VkDescriptorUpdateTemplateEntry>(VkDescriptorUpdateTemplateEntry const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.dstBinding, "uint32_t dstBinding", os, indent +1);
    Print(src.dstArrayElement, "uint32_t dstArrayElement", os, indent +1);
    Print(src.descriptorCount, "uint32_t descriptorCount", os, indent +1);
    Print(src.descriptorType, "VkDescriptorType descriptorType", os, indent +1);
    Print(src.offset, "size_t offset", os, indent +1);
    Print(src.stride, "size_t stride", os, indent +1);
}

template <>
inline void Print<VkDeviceAddressBindingCallbackDataEXT>(VkDeviceAddressBindingCallbackDataEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.flags, "VkDeviceAddressBindingFlagsEXT flags", os, indent +1);
    Print(src.baseAddress, "VkDeviceAddress baseAddress", os, indent +1);
    Print(src.size, "VkDeviceSize size", os, indent +1);
    Print(src.bindingType, "VkDeviceAddressBindingTypeEXT bindingType", os, indent +1);
}

template <>
inline void Print<VkDeviceBufferMemoryRequirements>(VkDeviceBufferMemoryRequirements const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintPointer(src.pCreateInfo, "const VkBufferCreateInfo * pCreateInfo", os, indent +1);
}

template <>
inline void Print<VkDeviceCreateInfo>(VkDeviceCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkDeviceCreateFlags flags", os, indent +1);
    Print(src.queueCreateInfoCount, "uint32_t queueCreateInfoCount", os, indent +1);
            if( src.queueCreateInfoCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to queueCreateInfoCount" << std::endl;
            } else {
        PrintPointer(src.pQueueCreateInfos, "const VkDeviceQueueCreateInfo * pQueueCreateInfos", os, indent +1);
            }

    Print(src.enabledLayerCount, "uint32_t enabledLayerCount", os, indent +1);
            if( src.enabledLayerCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to enabledLayerCount" << std::endl;
            } else {
        PrintPointer(src.ppEnabledLayerNames, "const char *const * ppEnabledLayerNames", os, indent +1);
            }

    Print(src.enabledExtensionCount, "uint32_t enabledExtensionCount", os, indent +1);
            if( src.enabledExtensionCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to enabledExtensionCount" << std::endl;
            } else {
        PrintPointer(src.ppEnabledExtensionNames, "const char *const * ppEnabledExtensionNames", os, indent +1);
            }

        PrintPointer(src.pEnabledFeatures, "const VkPhysicalDeviceFeatures * pEnabledFeatures", os, indent +1);
}

template <>
inline void Print<VkDeviceDeviceMemoryReportCreateInfoEXT>(VkDeviceDeviceMemoryReportCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkDeviceMemoryReportFlagsEXT flags", os, indent +1);
        PrintPointer(src.pfnUserCallback, "PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback", os, indent +1);
        PrintPointer(src.pUserData, "void * pUserData", os, indent +1);
}

template <>
inline void Print<VkDeviceDiagnosticsConfigCreateInfoNV>(VkDeviceDiagnosticsConfigCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkDeviceDiagnosticsConfigFlagsNV flags", os, indent +1);
}

template <>
inline void Print<VkDeviceEventInfoEXT>(VkDeviceEventInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.deviceEvent, "VkDeviceEventTypeEXT deviceEvent", os, indent +1);
}

template <>
inline void Print<VkDeviceFaultAddressInfoEXT>(VkDeviceFaultAddressInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.addressType, "VkDeviceFaultAddressTypeEXT addressType", os, indent +1);
    Print(src.reportedAddress, "VkDeviceAddress reportedAddress", os, indent +1);
    Print(src.addressPrecision, "VkDeviceSize addressPrecision", os, indent +1);
}

template <>
inline void Print<VkDeviceFaultCountsEXT>(VkDeviceFaultCountsEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.addressInfoCount, "uint32_t addressInfoCount", os, indent +1);
    Print(src.vendorInfoCount, "uint32_t vendorInfoCount", os, indent +1);
    Print(src.vendorBinarySize, "VkDeviceSize vendorBinarySize", os, indent +1);
}

template <>
inline void Print<VkDeviceFaultInfoEXT>(VkDeviceFaultInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    PrintArray(src.description, 256, "char [256] description", os, indent + 1);
        PrintPointer(src.pAddressInfos, "VkDeviceFaultAddressInfoEXT * pAddressInfos", os, indent +1);
        PrintPointer(src.pVendorInfos, "VkDeviceFaultVendorInfoEXT * pVendorInfos", os, indent +1);
        PrintPointer(src.pVendorBinaryData, "void * pVendorBinaryData", os, indent +1);
}

template <>
inline void Print<VkDeviceFaultVendorBinaryHeaderVersionOneEXT>(VkDeviceFaultVendorBinaryHeaderVersionOneEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.headerSize, "uint32_t headerSize", os, indent +1);
    Print(src.headerVersion, "VkDeviceFaultVendorBinaryHeaderVersionEXT headerVersion", os, indent +1);
    Print(src.vendorID, "uint32_t vendorID", os, indent +1);
    Print(src.deviceID, "uint32_t deviceID", os, indent +1);
    Print(src.driverVersion, "uint32_t driverVersion", os, indent +1);
    PrintArray(src.pipelineCacheUUID, 16, "uint8_t [16] pipelineCacheUUID", os, indent + 1);
    Print(src.applicationNameOffset, "uint32_t applicationNameOffset", os, indent +1);
    Print(src.applicationVersion, "uint32_t applicationVersion", os, indent +1);
    Print(src.engineNameOffset, "uint32_t engineNameOffset", os, indent +1);
}

template <>
inline void Print<VkDeviceFaultVendorInfoEXT>(VkDeviceFaultVendorInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    PrintArray(src.description, 256, "char [256] description", os, indent + 1);
    Print(src.vendorFaultCode, "uint64_t vendorFaultCode", os, indent +1);
    Print(src.vendorFaultData, "uint64_t vendorFaultData", os, indent +1);
}

template <>
inline void Print<VkDeviceGroupBindSparseInfo>(VkDeviceGroupBindSparseInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.resourceDeviceIndex, "uint32_t resourceDeviceIndex", os, indent +1);
    Print(src.memoryDeviceIndex, "uint32_t memoryDeviceIndex", os, indent +1);
}

template <>
inline void Print<VkDeviceGroupCommandBufferBeginInfo>(VkDeviceGroupCommandBufferBeginInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.deviceMask, "uint32_t deviceMask", os, indent +1);
}

template <>
inline void Print<VkDeviceGroupDeviceCreateInfo>(VkDeviceGroupDeviceCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.physicalDeviceCount, "uint32_t physicalDeviceCount", os, indent +1);
            if( src.physicalDeviceCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to physicalDeviceCount" << std::endl;
            } else {
        PrintPointer(src.pPhysicalDevices, "const VkPhysicalDevice * pPhysicalDevices", os, indent +1);
            }

}

template <>
inline void Print<VkDeviceGroupPresentCapabilitiesKHR>(VkDeviceGroupPresentCapabilitiesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    PrintArray(src.presentMask, 32, "uint32_t [32] presentMask", os, indent + 1);
    Print(src.modes, "VkDeviceGroupPresentModeFlagsKHR modes", os, indent +1);
}

template <>
inline void Print<VkDeviceGroupPresentInfoKHR>(VkDeviceGroupPresentInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.swapchainCount, "uint32_t swapchainCount", os, indent +1);
            if( src.swapchainCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to swapchainCount" << std::endl;
            } else {
        PrintPointer(src.pDeviceMasks, "const uint32_t * pDeviceMasks", os, indent +1);
            }

    Print(src.mode, "VkDeviceGroupPresentModeFlagBitsKHR mode", os, indent +1);
}

template <>
inline void Print<VkDeviceGroupRenderPassBeginInfo>(VkDeviceGroupRenderPassBeginInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.deviceMask, "uint32_t deviceMask", os, indent +1);
    Print(src.deviceRenderAreaCount, "uint32_t deviceRenderAreaCount", os, indent +1);
            if( src.deviceRenderAreaCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to deviceRenderAreaCount" << std::endl;
            } else {
        PrintPointer(src.pDeviceRenderAreas, "const VkRect2D * pDeviceRenderAreas", os, indent +1);
            }

}

template <>
inline void Print<VkDeviceGroupSubmitInfo>(VkDeviceGroupSubmitInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.waitSemaphoreCount, "uint32_t waitSemaphoreCount", os, indent +1);
            if( src.waitSemaphoreCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to waitSemaphoreCount" << std::endl;
            } else {
        PrintPointer(src.pWaitSemaphoreDeviceIndices, "const uint32_t * pWaitSemaphoreDeviceIndices", os, indent +1);
            }

    Print(src.commandBufferCount, "uint32_t commandBufferCount", os, indent +1);
            if( src.commandBufferCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to commandBufferCount" << std::endl;
            } else {
        PrintPointer(src.pCommandBufferDeviceMasks, "const uint32_t * pCommandBufferDeviceMasks", os, indent +1);
            }

    Print(src.signalSemaphoreCount, "uint32_t signalSemaphoreCount", os, indent +1);
            if( src.signalSemaphoreCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to signalSemaphoreCount" << std::endl;
            } else {
        PrintPointer(src.pSignalSemaphoreDeviceIndices, "const uint32_t * pSignalSemaphoreDeviceIndices", os, indent +1);
            }

}

template <>
inline void Print<VkDeviceGroupSwapchainCreateInfoKHR>(VkDeviceGroupSwapchainCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.modes, "VkDeviceGroupPresentModeFlagsKHR modes", os, indent +1);
}

template <>
inline void Print<VkDeviceImageMemoryRequirements>(VkDeviceImageMemoryRequirements const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintPointer(src.pCreateInfo, "const VkImageCreateInfo * pCreateInfo", os, indent +1);
    Print(src.planeAspect, "VkImageAspectFlagBits planeAspect", os, indent +1);
}

template <>
inline void Print<VkDeviceMemoryOpaqueCaptureAddressInfo>(VkDeviceMemoryOpaqueCaptureAddressInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.memory, "VkDeviceMemory memory", os, indent +1);
}

template <>
inline void Print<VkDeviceMemoryOverallocationCreateInfoAMD>(VkDeviceMemoryOverallocationCreateInfoAMD const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.overallocationBehavior, "VkMemoryOverallocationBehaviorAMD overallocationBehavior", os, indent +1);
}

template <>
inline void Print<VkDeviceMemoryReportCallbackDataEXT>(VkDeviceMemoryReportCallbackDataEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.flags, "VkDeviceMemoryReportFlagsEXT flags", os, indent +1);
    Print(src.type, "VkDeviceMemoryReportEventTypeEXT type", os, indent +1);
    Print(src.memoryObjectId, "uint64_t memoryObjectId", os, indent +1);
    Print(src.size, "VkDeviceSize size", os, indent +1);
    Print(src.objectType, "VkObjectType objectType", os, indent +1);
    Print(src.objectHandle, "uint64_t objectHandle", os, indent +1);
    Print(src.heapIndex, "uint32_t heapIndex", os, indent +1);
}

template <>
inline void Print<VkDevicePrivateDataCreateInfo>(VkDevicePrivateDataCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.privateDataSlotRequestCount, "uint32_t privateDataSlotRequestCount", os, indent +1);
}

template <>
inline void Print<VkDeviceQueueCreateInfo>(VkDeviceQueueCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkDeviceQueueCreateFlags flags", os, indent +1);
    Print(src.queueFamilyIndex, "uint32_t queueFamilyIndex", os, indent +1);
    Print(src.queueCount, "uint32_t queueCount", os, indent +1);
            if( src.queueCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to queueCount" << std::endl;
            } else {
        PrintPointer(src.pQueuePriorities, "const float * pQueuePriorities", os, indent +1);
            }

}

template <>
inline void Print<VkDeviceQueueGlobalPriorityCreateInfoKHR>(VkDeviceQueueGlobalPriorityCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.globalPriority, "VkQueueGlobalPriorityKHR globalPriority", os, indent +1);
}

template <>
inline void Print<VkDeviceQueueInfo2>(VkDeviceQueueInfo2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkDeviceQueueCreateFlags flags", os, indent +1);
    Print(src.queueFamilyIndex, "uint32_t queueFamilyIndex", os, indent +1);
    Print(src.queueIndex, "uint32_t queueIndex", os, indent +1);
}

template <>
inline void Print<VkDirectDriverLoadingInfoLUNARG>(VkDirectDriverLoadingInfoLUNARG const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.flags, "VkDirectDriverLoadingFlagsLUNARG flags", os, indent +1);
        PrintPointer(src.pfnGetInstanceProcAddr, "PFN_vkGetInstanceProcAddrLUNARG pfnGetInstanceProcAddr", os, indent +1);
}

template <>
inline void Print<VkDirectDriverLoadingListLUNARG>(VkDirectDriverLoadingListLUNARG const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.mode, "VkDirectDriverLoadingModeLUNARG mode", os, indent +1);
    Print(src.driverCount, "uint32_t driverCount", os, indent +1);
            if( src.driverCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to driverCount" << std::endl;
            } else {
        PrintPointer(src.pDrivers, "const VkDirectDriverLoadingInfoLUNARG * pDrivers", os, indent +1);
            }

}

template <>
inline void Print<VkDispatchIndirectCommand>(VkDispatchIndirectCommand const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.x, "uint32_t x", os, indent +1);
    Print(src.y, "uint32_t y", os, indent +1);
    Print(src.z, "uint32_t z", os, indent +1);
}

template <>
inline void Print<VkDisplayEventInfoEXT>(VkDisplayEventInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.displayEvent, "VkDisplayEventTypeEXT displayEvent", os, indent +1);
}

template <>
inline void Print<VkDisplayModeCreateInfoKHR>(VkDisplayModeCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkDisplayModeCreateFlagsKHR flags", os, indent +1);
    Print(src.parameters, "VkDisplayModeParametersKHR parameters", os, indent +1);
}

template <>
inline void Print<VkDisplayModeParametersKHR>(VkDisplayModeParametersKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.visibleRegion, "VkExtent2D visibleRegion", os, indent +1);
    Print(src.refreshRate, "uint32_t refreshRate", os, indent +1);
}

template <>
inline void Print<VkDisplayModeProperties2KHR>(VkDisplayModeProperties2KHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.displayModeProperties, "VkDisplayModePropertiesKHR displayModeProperties", os, indent +1);
}

template <>
inline void Print<VkDisplayModePropertiesKHR>(VkDisplayModePropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
        PrintInterfacePointer(src.displayMode, "VkDisplayModeKHR displayMode", os, indent +1);
    Print(src.parameters, "VkDisplayModeParametersKHR parameters", os, indent +1);
}

template <>
inline void Print<VkDisplayNativeHdrSurfaceCapabilitiesAMD>(VkDisplayNativeHdrSurfaceCapabilitiesAMD const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.localDimmingSupport, "VkBool32 localDimmingSupport", os, indent +1);
}

template <>
inline void Print<VkDisplayPlaneCapabilities2KHR>(VkDisplayPlaneCapabilities2KHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.capabilities, "VkDisplayPlaneCapabilitiesKHR capabilities", os, indent +1);
}

template <>
inline void Print<VkDisplayPlaneCapabilitiesKHR>(VkDisplayPlaneCapabilitiesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.supportedAlpha, "VkDisplayPlaneAlphaFlagsKHR supportedAlpha", os, indent +1);
    Print(src.minSrcPosition, "VkOffset2D minSrcPosition", os, indent +1);
    Print(src.maxSrcPosition, "VkOffset2D maxSrcPosition", os, indent +1);
    Print(src.minSrcExtent, "VkExtent2D minSrcExtent", os, indent +1);
    Print(src.maxSrcExtent, "VkExtent2D maxSrcExtent", os, indent +1);
    Print(src.minDstPosition, "VkOffset2D minDstPosition", os, indent +1);
    Print(src.maxDstPosition, "VkOffset2D maxDstPosition", os, indent +1);
    Print(src.minDstExtent, "VkExtent2D minDstExtent", os, indent +1);
    Print(src.maxDstExtent, "VkExtent2D maxDstExtent", os, indent +1);
}

template <>
inline void Print<VkDisplayPlaneInfo2KHR>(VkDisplayPlaneInfo2KHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.mode, "VkDisplayModeKHR mode", os, indent +1);
    Print(src.planeIndex, "uint32_t planeIndex", os, indent +1);
}

template <>
inline void Print<VkDisplayPlaneProperties2KHR>(VkDisplayPlaneProperties2KHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.displayPlaneProperties, "VkDisplayPlanePropertiesKHR displayPlaneProperties", os, indent +1);
}

template <>
inline void Print<VkDisplayPlanePropertiesKHR>(VkDisplayPlanePropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
        PrintInterfacePointer(src.currentDisplay, "VkDisplayKHR currentDisplay", os, indent +1);
    Print(src.currentStackIndex, "uint32_t currentStackIndex", os, indent +1);
}

template <>
inline void Print<VkDisplayPowerInfoEXT>(VkDisplayPowerInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.powerState, "VkDisplayPowerStateEXT powerState", os, indent +1);
}

template <>
inline void Print<VkDisplayPresentInfoKHR>(VkDisplayPresentInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.srcRect, "VkRect2D srcRect", os, indent +1);
    Print(src.dstRect, "VkRect2D dstRect", os, indent +1);
    Print(src.persistent, "VkBool32 persistent", os, indent +1);
}

template <>
inline void Print<VkDisplayProperties2KHR>(VkDisplayProperties2KHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.displayProperties, "VkDisplayPropertiesKHR displayProperties", os, indent +1);
}

template <>
inline void Print<VkDisplayPropertiesKHR>(VkDisplayPropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
        PrintInterfacePointer(src.display, "VkDisplayKHR display", os, indent +1);
        PrintPointer(src.displayName, "const char * displayName", os, indent +1);
    Print(src.physicalDimensions, "VkExtent2D physicalDimensions", os, indent +1);
    Print(src.physicalResolution, "VkExtent2D physicalResolution", os, indent +1);
    Print(src.supportedTransforms, "VkSurfaceTransformFlagsKHR supportedTransforms", os, indent +1);
    Print(src.planeReorderPossible, "VkBool32 planeReorderPossible", os, indent +1);
    Print(src.persistentContent, "VkBool32 persistentContent", os, indent +1);
}

template <>
inline void Print<VkDisplaySurfaceCreateInfoKHR>(VkDisplaySurfaceCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkDisplaySurfaceCreateFlagsKHR flags", os, indent +1);
        PrintInterfacePointer(src.displayMode, "VkDisplayModeKHR displayMode", os, indent +1);
    Print(src.planeIndex, "uint32_t planeIndex", os, indent +1);
    Print(src.planeStackIndex, "uint32_t planeStackIndex", os, indent +1);
    Print(src.transform, "VkSurfaceTransformFlagBitsKHR transform", os, indent +1);
    Print(src.globalAlpha, "float globalAlpha", os, indent +1);
    Print(src.alphaMode, "VkDisplayPlaneAlphaFlagBitsKHR alphaMode", os, indent +1);
    Print(src.imageExtent, "VkExtent2D imageExtent", os, indent +1);
}

template <>
inline void Print<VkDrawIndexedIndirectCommand>(VkDrawIndexedIndirectCommand const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.indexCount, "uint32_t indexCount", os, indent +1);
    Print(src.instanceCount, "uint32_t instanceCount", os, indent +1);
    Print(src.firstIndex, "uint32_t firstIndex", os, indent +1);
    Print(src.vertexOffset, "int32_t vertexOffset", os, indent +1);
    Print(src.firstInstance, "uint32_t firstInstance", os, indent +1);
}

template <>
inline void Print<VkDrawIndirectCommand>(VkDrawIndirectCommand const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.vertexCount, "uint32_t vertexCount", os, indent +1);
    Print(src.instanceCount, "uint32_t instanceCount", os, indent +1);
    Print(src.firstVertex, "uint32_t firstVertex", os, indent +1);
    Print(src.firstInstance, "uint32_t firstInstance", os, indent +1);
}

template <>
inline void Print<VkDrawMeshTasksIndirectCommandEXT>(VkDrawMeshTasksIndirectCommandEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.groupCountX, "uint32_t groupCountX", os, indent +1);
    Print(src.groupCountY, "uint32_t groupCountY", os, indent +1);
    Print(src.groupCountZ, "uint32_t groupCountZ", os, indent +1);
}

template <>
inline void Print<VkDrawMeshTasksIndirectCommandNV>(VkDrawMeshTasksIndirectCommandNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.taskCount, "uint32_t taskCount", os, indent +1);
    Print(src.firstTask, "uint32_t firstTask", os, indent +1);
}

template <>
inline void Print<VkDrmFormatModifierProperties2EXT>(VkDrmFormatModifierProperties2EXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.drmFormatModifier, "uint64_t drmFormatModifier", os, indent +1);
    Print(src.drmFormatModifierPlaneCount, "uint32_t drmFormatModifierPlaneCount", os, indent +1);
    Print(src.drmFormatModifierTilingFeatures, "VkFormatFeatureFlags2 drmFormatModifierTilingFeatures", os, indent +1);
}

template <>
inline void Print<VkDrmFormatModifierPropertiesEXT>(VkDrmFormatModifierPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.drmFormatModifier, "uint64_t drmFormatModifier", os, indent +1);
    Print(src.drmFormatModifierPlaneCount, "uint32_t drmFormatModifierPlaneCount", os, indent +1);
    Print(src.drmFormatModifierTilingFeatures, "VkFormatFeatureFlags drmFormatModifierTilingFeatures", os, indent +1);
}

template <>
inline void Print<VkDrmFormatModifierPropertiesList2EXT>(VkDrmFormatModifierPropertiesList2EXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.drmFormatModifierCount, "uint32_t drmFormatModifierCount", os, indent +1);
            if( src.drmFormatModifierCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to drmFormatModifierCount" << std::endl;
            } else {
        PrintPointer(src.pDrmFormatModifierProperties, "VkDrmFormatModifierProperties2EXT * pDrmFormatModifierProperties", os, indent +1);
            }

}

template <>
inline void Print<VkDrmFormatModifierPropertiesListEXT>(VkDrmFormatModifierPropertiesListEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.drmFormatModifierCount, "uint32_t drmFormatModifierCount", os, indent +1);
            if( src.drmFormatModifierCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to drmFormatModifierCount" << std::endl;
            } else {
        PrintPointer(src.pDrmFormatModifierProperties, "VkDrmFormatModifierPropertiesEXT * pDrmFormatModifierProperties", os, indent +1);
            }

}

template <>
inline void Print<VkEventCreateInfo>(VkEventCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkEventCreateFlags flags", os, indent +1);
}

template <>
inline void Print<VkExportFenceCreateInfo>(VkExportFenceCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.handleTypes, "VkExternalFenceHandleTypeFlags handleTypes", os, indent +1);
}

template <>
inline void Print<VkExportMemoryAllocateInfo>(VkExportMemoryAllocateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.handleTypes, "VkExternalMemoryHandleTypeFlags handleTypes", os, indent +1);
}

template <>
inline void Print<VkExportMemoryAllocateInfoNV>(VkExportMemoryAllocateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.handleTypes, "VkExternalMemoryHandleTypeFlagsNV handleTypes", os, indent +1);
}

template <>
inline void Print<VkExportSemaphoreCreateInfo>(VkExportSemaphoreCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.handleTypes, "VkExternalSemaphoreHandleTypeFlags handleTypes", os, indent +1);
}

template <>
inline void Print<VkExtensionProperties>(VkExtensionProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    PrintArray(src.extensionName, 256, "char [256] extensionName", os, indent + 1);
    Print(src.specVersion, "uint32_t specVersion", os, indent +1);
}

template <>
inline void Print<VkExtent2D>(VkExtent2D const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.width, "uint32_t width", os, indent +1);
    Print(src.height, "uint32_t height", os, indent +1);
}

template <>
inline void Print<VkExtent3D>(VkExtent3D const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.width, "uint32_t width", os, indent +1);
    Print(src.height, "uint32_t height", os, indent +1);
    Print(src.depth, "uint32_t depth", os, indent +1);
}

template <>
inline void Print<VkExternalBufferProperties>(VkExternalBufferProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.externalMemoryProperties, "VkExternalMemoryProperties externalMemoryProperties", os, indent +1);
}

template <>
inline void Print<VkExternalFenceProperties>(VkExternalFenceProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.exportFromImportedHandleTypes, "VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes", os, indent +1);
    Print(src.compatibleHandleTypes, "VkExternalFenceHandleTypeFlags compatibleHandleTypes", os, indent +1);
    Print(src.externalFenceFeatures, "VkExternalFenceFeatureFlags externalFenceFeatures", os, indent +1);
}

template <>
inline void Print<VkExternalImageFormatProperties>(VkExternalImageFormatProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.externalMemoryProperties, "VkExternalMemoryProperties externalMemoryProperties", os, indent +1);
}

template <>
inline void Print<VkExternalImageFormatPropertiesNV>(VkExternalImageFormatPropertiesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.imageFormatProperties, "VkImageFormatProperties imageFormatProperties", os, indent +1);
    Print(src.externalMemoryFeatures, "VkExternalMemoryFeatureFlagsNV externalMemoryFeatures", os, indent +1);
    Print(src.exportFromImportedHandleTypes, "VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes", os, indent +1);
    Print(src.compatibleHandleTypes, "VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes", os, indent +1);
}

template <>
inline void Print<VkExternalMemoryBufferCreateInfo>(VkExternalMemoryBufferCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.handleTypes, "VkExternalMemoryHandleTypeFlags handleTypes", os, indent +1);
}

template <>
inline void Print<VkExternalMemoryImageCreateInfo>(VkExternalMemoryImageCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.handleTypes, "VkExternalMemoryHandleTypeFlags handleTypes", os, indent +1);
}

template <>
inline void Print<VkExternalMemoryImageCreateInfoNV>(VkExternalMemoryImageCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.handleTypes, "VkExternalMemoryHandleTypeFlagsNV handleTypes", os, indent +1);
}

template <>
inline void Print<VkExternalMemoryProperties>(VkExternalMemoryProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.externalMemoryFeatures, "VkExternalMemoryFeatureFlags externalMemoryFeatures", os, indent +1);
    Print(src.exportFromImportedHandleTypes, "VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes", os, indent +1);
    Print(src.compatibleHandleTypes, "VkExternalMemoryHandleTypeFlags compatibleHandleTypes", os, indent +1);
}

template <>
inline void Print<VkExternalSemaphoreProperties>(VkExternalSemaphoreProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.exportFromImportedHandleTypes, "VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes", os, indent +1);
    Print(src.compatibleHandleTypes, "VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes", os, indent +1);
    Print(src.externalSemaphoreFeatures, "VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures", os, indent +1);
}

template <>
inline void Print<VkFenceCreateInfo>(VkFenceCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkFenceCreateFlags flags", os, indent +1);
}

template <>
inline void Print<VkFenceGetFdInfoKHR>(VkFenceGetFdInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.fence, "VkFence fence", os, indent +1);
    Print(src.handleType, "VkExternalFenceHandleTypeFlagBits handleType", os, indent +1);
}

template <>
inline void Print<VkFilterCubicImageViewImageFormatPropertiesEXT>(VkFilterCubicImageViewImageFormatPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.filterCubic, "VkBool32 filterCubic", os, indent +1);
    Print(src.filterCubicMinmax, "VkBool32 filterCubicMinmax", os, indent +1);
}

template <>
inline void Print<VkFormatProperties>(VkFormatProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.linearTilingFeatures, "VkFormatFeatureFlags linearTilingFeatures", os, indent +1);
    Print(src.optimalTilingFeatures, "VkFormatFeatureFlags optimalTilingFeatures", os, indent +1);
    Print(src.bufferFeatures, "VkFormatFeatureFlags bufferFeatures", os, indent +1);
}

template <>
inline void Print<VkFormatProperties2>(VkFormatProperties2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.formatProperties, "VkFormatProperties formatProperties", os, indent +1);
}

template <>
inline void Print<VkFormatProperties3>(VkFormatProperties3 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.linearTilingFeatures, "VkFormatFeatureFlags2 linearTilingFeatures", os, indent +1);
    Print(src.optimalTilingFeatures, "VkFormatFeatureFlags2 optimalTilingFeatures", os, indent +1);
    Print(src.bufferFeatures, "VkFormatFeatureFlags2 bufferFeatures", os, indent +1);
}

template <>
inline void Print<VkFragmentShadingRateAttachmentInfoKHR>(VkFragmentShadingRateAttachmentInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintPointer(src.pFragmentShadingRateAttachment, "const VkAttachmentReference2 * pFragmentShadingRateAttachment", os, indent +1);
    Print(src.shadingRateAttachmentTexelSize, "VkExtent2D shadingRateAttachmentTexelSize", os, indent +1);
}

template <>
inline void Print<VkFramebufferAttachmentImageInfo>(VkFramebufferAttachmentImageInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkImageCreateFlags flags", os, indent +1);
    Print(src.usage, "VkImageUsageFlags usage", os, indent +1);
    Print(src.width, "uint32_t width", os, indent +1);
    Print(src.height, "uint32_t height", os, indent +1);
    Print(src.layerCount, "uint32_t layerCount", os, indent +1);
    Print(src.viewFormatCount, "uint32_t viewFormatCount", os, indent +1);
            if( src.viewFormatCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to viewFormatCount" << std::endl;
            } else {
        PrintPointer(src.pViewFormats, "const VkFormat * pViewFormats", os, indent +1);
            }

}

template <>
inline void Print<VkFramebufferAttachmentsCreateInfo>(VkFramebufferAttachmentsCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.attachmentImageInfoCount, "uint32_t attachmentImageInfoCount", os, indent +1);
            if( src.attachmentImageInfoCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to attachmentImageInfoCount" << std::endl;
            } else {
        PrintPointer(src.pAttachmentImageInfos, "const VkFramebufferAttachmentImageInfo * pAttachmentImageInfos", os, indent +1);
            }

}

template <>
inline void Print<VkFramebufferCreateInfo>(VkFramebufferCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkFramebufferCreateFlags flags", os, indent +1);
        PrintInterfacePointer(src.renderPass, "VkRenderPass renderPass", os, indent +1);
    Print(src.attachmentCount, "uint32_t attachmentCount", os, indent +1);
            if( src.attachmentCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to attachmentCount" << std::endl;
            } else {
        PrintPointer(src.pAttachments, "const VkImageView * pAttachments", os, indent +1);
            }

    Print(src.width, "uint32_t width", os, indent +1);
    Print(src.height, "uint32_t height", os, indent +1);
    Print(src.layers, "uint32_t layers", os, indent +1);
}

template <>
inline void Print<VkFramebufferMixedSamplesCombinationNV>(VkFramebufferMixedSamplesCombinationNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.coverageReductionMode, "VkCoverageReductionModeNV coverageReductionMode", os, indent +1);
    Print(src.rasterizationSamples, "VkSampleCountFlagBits rasterizationSamples", os, indent +1);
    Print(src.depthStencilSamples, "VkSampleCountFlags depthStencilSamples", os, indent +1);
    Print(src.colorSamples, "VkSampleCountFlags colorSamples", os, indent +1);
}

template <>
inline void Print<VkGeneratedCommandsInfoNV>(VkGeneratedCommandsInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.pipelineBindPoint, "VkPipelineBindPoint pipelineBindPoint", os, indent +1);
        PrintInterfacePointer(src.pipeline, "VkPipeline pipeline", os, indent +1);
        PrintInterfacePointer(src.indirectCommandsLayout, "VkIndirectCommandsLayoutNV indirectCommandsLayout", os, indent +1);
    Print(src.streamCount, "uint32_t streamCount", os, indent +1);
            if( src.streamCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to streamCount" << std::endl;
            } else {
        PrintPointer(src.pStreams, "const VkIndirectCommandsStreamNV * pStreams", os, indent +1);
            }

    Print(src.sequencesCount, "uint32_t sequencesCount", os, indent +1);
        PrintInterfacePointer(src.preprocessBuffer, "VkBuffer preprocessBuffer", os, indent +1);
    Print(src.preprocessOffset, "VkDeviceSize preprocessOffset", os, indent +1);
    Print(src.preprocessSize, "VkDeviceSize preprocessSize", os, indent +1);
        PrintInterfacePointer(src.sequencesCountBuffer, "VkBuffer sequencesCountBuffer", os, indent +1);
    Print(src.sequencesCountOffset, "VkDeviceSize sequencesCountOffset", os, indent +1);
        PrintInterfacePointer(src.sequencesIndexBuffer, "VkBuffer sequencesIndexBuffer", os, indent +1);
    Print(src.sequencesIndexOffset, "VkDeviceSize sequencesIndexOffset", os, indent +1);
}

template <>
inline void Print<VkGeneratedCommandsMemoryRequirementsInfoNV>(VkGeneratedCommandsMemoryRequirementsInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.pipelineBindPoint, "VkPipelineBindPoint pipelineBindPoint", os, indent +1);
        PrintInterfacePointer(src.pipeline, "VkPipeline pipeline", os, indent +1);
        PrintInterfacePointer(src.indirectCommandsLayout, "VkIndirectCommandsLayoutNV indirectCommandsLayout", os, indent +1);
    Print(src.maxSequencesCount, "uint32_t maxSequencesCount", os, indent +1);
}

template <>
inline void Print<VkGeometryAABBNV>(VkGeometryAABBNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.aabbData, "VkBuffer aabbData", os, indent +1);
    Print(src.numAABBs, "uint32_t numAABBs", os, indent +1);
    Print(src.stride, "uint32_t stride", os, indent +1);
    Print(src.offset, "VkDeviceSize offset", os, indent +1);
}

template <>
inline void Print<VkGeometryDataNV>(VkGeometryDataNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.triangles, "VkGeometryTrianglesNV triangles", os, indent +1);
    Print(src.aabbs, "VkGeometryAABBNV aabbs", os, indent +1);
}

template <>
inline void Print<VkGeometryNV>(VkGeometryNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.geometryType, "VkGeometryTypeKHR geometryType", os, indent +1);
    Print(src.geometry, "VkGeometryDataNV geometry", os, indent +1);
    Print(src.flags, "VkGeometryFlagsKHR flags", os, indent +1);
}

template <>
inline void Print<VkGeometryTrianglesNV>(VkGeometryTrianglesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.vertexData, "VkBuffer vertexData", os, indent +1);
    Print(src.vertexOffset, "VkDeviceSize vertexOffset", os, indent +1);
    Print(src.vertexCount, "uint32_t vertexCount", os, indent +1);
    Print(src.vertexStride, "VkDeviceSize vertexStride", os, indent +1);
    Print(src.vertexFormat, "VkFormat vertexFormat", os, indent +1);
        PrintInterfacePointer(src.indexData, "VkBuffer indexData", os, indent +1);
    Print(src.indexOffset, "VkDeviceSize indexOffset", os, indent +1);
    Print(src.indexCount, "uint32_t indexCount", os, indent +1);
    Print(src.indexType, "VkIndexType indexType", os, indent +1);
        PrintInterfacePointer(src.transformData, "VkBuffer transformData", os, indent +1);
    Print(src.transformOffset, "VkDeviceSize transformOffset", os, indent +1);
}

template <>
inline void Print<VkGraphicsPipelineCreateInfo>(VkGraphicsPipelineCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkPipelineCreateFlags flags", os, indent +1);
    Print(src.stageCount, "uint32_t stageCount", os, indent +1);
            if( src.stageCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to stageCount" << std::endl;
            } else {
        PrintPointer(src.pStages, "const VkPipelineShaderStageCreateInfo * pStages", os, indent +1);
            }

        PrintPointer(src.pVertexInputState, "const VkPipelineVertexInputStateCreateInfo * pVertexInputState", os, indent +1);
        PrintPointer(src.pInputAssemblyState, "const VkPipelineInputAssemblyStateCreateInfo * pInputAssemblyState", os, indent +1);
        PrintPointer(src.pTessellationState, "const VkPipelineTessellationStateCreateInfo * pTessellationState", os, indent +1);
        PrintPointer(src.pViewportState, "const VkPipelineViewportStateCreateInfo * pViewportState", os, indent +1);
        PrintPointer(src.pRasterizationState, "const VkPipelineRasterizationStateCreateInfo * pRasterizationState", os, indent +1);
        PrintPointer(src.pMultisampleState, "const VkPipelineMultisampleStateCreateInfo * pMultisampleState", os, indent +1);
        PrintPointer(src.pDepthStencilState, "const VkPipelineDepthStencilStateCreateInfo * pDepthStencilState", os, indent +1);
        PrintPointer(src.pColorBlendState, "const VkPipelineColorBlendStateCreateInfo * pColorBlendState", os, indent +1);
        PrintPointer(src.pDynamicState, "const VkPipelineDynamicStateCreateInfo * pDynamicState", os, indent +1);
        PrintInterfacePointer(src.layout, "VkPipelineLayout layout", os, indent +1);
        PrintInterfacePointer(src.renderPass, "VkRenderPass renderPass", os, indent +1);
    Print(src.subpass, "uint32_t subpass", os, indent +1);
        PrintInterfacePointer(src.basePipelineHandle, "VkPipeline basePipelineHandle", os, indent +1);
    Print(src.basePipelineIndex, "int32_t basePipelineIndex", os, indent +1);
}

template <>
inline void Print<VkGraphicsPipelineLibraryCreateInfoEXT>(VkGraphicsPipelineLibraryCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.flags, "VkGraphicsPipelineLibraryFlagsEXT flags", os, indent +1);
}

template <>
inline void Print<VkGraphicsPipelineShaderGroupsCreateInfoNV>(VkGraphicsPipelineShaderGroupsCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.groupCount, "uint32_t groupCount", os, indent +1);
            if( src.groupCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to groupCount" << std::endl;
            } else {
        PrintPointer(src.pGroups, "const VkGraphicsShaderGroupCreateInfoNV * pGroups", os, indent +1);
            }

    Print(src.pipelineCount, "uint32_t pipelineCount", os, indent +1);
            if( src.pipelineCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to pipelineCount" << std::endl;
            } else {
        PrintPointer(src.pPipelines, "const VkPipeline * pPipelines", os, indent +1);
            }

}

template <>
inline void Print<VkGraphicsShaderGroupCreateInfoNV>(VkGraphicsShaderGroupCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.stageCount, "uint32_t stageCount", os, indent +1);
            if( src.stageCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to stageCount" << std::endl;
            } else {
        PrintPointer(src.pStages, "const VkPipelineShaderStageCreateInfo * pStages", os, indent +1);
            }

        PrintPointer(src.pVertexInputState, "const VkPipelineVertexInputStateCreateInfo * pVertexInputState", os, indent +1);
        PrintPointer(src.pTessellationState, "const VkPipelineTessellationStateCreateInfo * pTessellationState", os, indent +1);
}

template <>
inline void Print<VkHdrMetadataEXT>(VkHdrMetadataEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.displayPrimaryRed, "VkXYColorEXT displayPrimaryRed", os, indent +1);
    Print(src.displayPrimaryGreen, "VkXYColorEXT displayPrimaryGreen", os, indent +1);
    Print(src.displayPrimaryBlue, "VkXYColorEXT displayPrimaryBlue", os, indent +1);
    Print(src.whitePoint, "VkXYColorEXT whitePoint", os, indent +1);
    Print(src.maxLuminance, "float maxLuminance", os, indent +1);
    Print(src.minLuminance, "float minLuminance", os, indent +1);
    Print(src.maxContentLightLevel, "float maxContentLightLevel", os, indent +1);
    Print(src.maxFrameAverageLightLevel, "float maxFrameAverageLightLevel", os, indent +1);
}

template <>
inline void Print<VkHeadlessSurfaceCreateInfoEXT>(VkHeadlessSurfaceCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkHeadlessSurfaceCreateFlagsEXT flags", os, indent +1);
}

template <>
inline void Print<VkImageBlit>(VkImageBlit const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.srcSubresource, "VkImageSubresourceLayers srcSubresource", os, indent +1);
    PrintArray(src.srcOffsets, 2, "VkOffset3D [2] srcOffsets", os, indent + 1);
    Print(src.dstSubresource, "VkImageSubresourceLayers dstSubresource", os, indent +1);
    PrintArray(src.dstOffsets, 2, "VkOffset3D [2] dstOffsets", os, indent + 1);
}

template <>
inline void Print<VkImageBlit2>(VkImageBlit2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.srcSubresource, "VkImageSubresourceLayers srcSubresource", os, indent +1);
    PrintArray(src.srcOffsets, 2, "VkOffset3D [2] srcOffsets", os, indent + 1);
    Print(src.dstSubresource, "VkImageSubresourceLayers dstSubresource", os, indent +1);
    PrintArray(src.dstOffsets, 2, "VkOffset3D [2] dstOffsets", os, indent + 1);
}

template <>
inline void Print<VkImageCaptureDescriptorDataInfoEXT>(VkImageCaptureDescriptorDataInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.image, "VkImage image", os, indent +1);
}

template <>
inline void Print<VkImageCompressionControlEXT>(VkImageCompressionControlEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkImageCompressionFlagsEXT flags", os, indent +1);
    Print(src.compressionControlPlaneCount, "uint32_t compressionControlPlaneCount", os, indent +1);
            if( src.compressionControlPlaneCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to compressionControlPlaneCount" << std::endl;
            } else {
        PrintPointer(src.pFixedRateFlags, "VkImageCompressionFixedRateFlagsEXT * pFixedRateFlags", os, indent +1);
            }

}

template <>
inline void Print<VkImageCompressionPropertiesEXT>(VkImageCompressionPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.imageCompressionFlags, "VkImageCompressionFlagsEXT imageCompressionFlags", os, indent +1);
    Print(src.imageCompressionFixedRateFlags, "VkImageCompressionFixedRateFlagsEXT imageCompressionFixedRateFlags", os, indent +1);
}

template <>
inline void Print<VkImageCopy>(VkImageCopy const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.srcSubresource, "VkImageSubresourceLayers srcSubresource", os, indent +1);
    Print(src.srcOffset, "VkOffset3D srcOffset", os, indent +1);
    Print(src.dstSubresource, "VkImageSubresourceLayers dstSubresource", os, indent +1);
    Print(src.dstOffset, "VkOffset3D dstOffset", os, indent +1);
    Print(src.extent, "VkExtent3D extent", os, indent +1);
}

template <>
inline void Print<VkImageCopy2>(VkImageCopy2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.srcSubresource, "VkImageSubresourceLayers srcSubresource", os, indent +1);
    Print(src.srcOffset, "VkOffset3D srcOffset", os, indent +1);
    Print(src.dstSubresource, "VkImageSubresourceLayers dstSubresource", os, indent +1);
    Print(src.dstOffset, "VkOffset3D dstOffset", os, indent +1);
    Print(src.extent, "VkExtent3D extent", os, indent +1);
}

template <>
inline void Print<VkImageCreateInfo>(VkImageCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkImageCreateFlags flags", os, indent +1);
    Print(src.imageType, "VkImageType imageType", os, indent +1);
    Print(src.format, "VkFormat format", os, indent +1);
    Print(src.extent, "VkExtent3D extent", os, indent +1);
    Print(src.mipLevels, "uint32_t mipLevels", os, indent +1);
    Print(src.arrayLayers, "uint32_t arrayLayers", os, indent +1);
    Print(src.samples, "VkSampleCountFlagBits samples", os, indent +1);
    Print(src.tiling, "VkImageTiling tiling", os, indent +1);
    Print(src.usage, "VkImageUsageFlags usage", os, indent +1);
    Print(src.sharingMode, "VkSharingMode sharingMode", os, indent +1);
    Print(src.queueFamilyIndexCount, "uint32_t queueFamilyIndexCount", os, indent +1);
            if( src.queueFamilyIndexCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to queueFamilyIndexCount" << std::endl;
            } else {
        PrintPointer(src.pQueueFamilyIndices, "const uint32_t * pQueueFamilyIndices", os, indent +1);
            }

    Print(src.initialLayout, "VkImageLayout initialLayout", os, indent +1);
}

template <>
inline void Print<VkImageDrmFormatModifierExplicitCreateInfoEXT>(VkImageDrmFormatModifierExplicitCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.drmFormatModifier, "uint64_t drmFormatModifier", os, indent +1);
    Print(src.drmFormatModifierPlaneCount, "uint32_t drmFormatModifierPlaneCount", os, indent +1);
            if( src.drmFormatModifierPlaneCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to drmFormatModifierPlaneCount" << std::endl;
            } else {
        PrintPointer(src.pPlaneLayouts, "const VkSubresourceLayout * pPlaneLayouts", os, indent +1);
            }

}

template <>
inline void Print<VkImageDrmFormatModifierListCreateInfoEXT>(VkImageDrmFormatModifierListCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.drmFormatModifierCount, "uint32_t drmFormatModifierCount", os, indent +1);
            if( src.drmFormatModifierCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to drmFormatModifierCount" << std::endl;
            } else {
        PrintPointer(src.pDrmFormatModifiers, "const uint64_t * pDrmFormatModifiers", os, indent +1);
            }

}

template <>
inline void Print<VkImageDrmFormatModifierPropertiesEXT>(VkImageDrmFormatModifierPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.drmFormatModifier, "uint64_t drmFormatModifier", os, indent +1);
}

template <>
inline void Print<VkImageFormatListCreateInfo>(VkImageFormatListCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.viewFormatCount, "uint32_t viewFormatCount", os, indent +1);
            if( src.viewFormatCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to viewFormatCount" << std::endl;
            } else {
        PrintPointer(src.pViewFormats, "const VkFormat * pViewFormats", os, indent +1);
            }

}

template <>
inline void Print<VkImageFormatProperties>(VkImageFormatProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.maxExtent, "VkExtent3D maxExtent", os, indent +1);
    Print(src.maxMipLevels, "uint32_t maxMipLevels", os, indent +1);
    Print(src.maxArrayLayers, "uint32_t maxArrayLayers", os, indent +1);
    Print(src.sampleCounts, "VkSampleCountFlags sampleCounts", os, indent +1);
    Print(src.maxResourceSize, "VkDeviceSize maxResourceSize", os, indent +1);
}

template <>
inline void Print<VkImageFormatProperties2>(VkImageFormatProperties2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.imageFormatProperties, "VkImageFormatProperties imageFormatProperties", os, indent +1);
}

template <>
inline void Print<VkImageMemoryBarrier>(VkImageMemoryBarrier const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.srcAccessMask, "VkAccessFlags srcAccessMask", os, indent +1);
    Print(src.dstAccessMask, "VkAccessFlags dstAccessMask", os, indent +1);
    Print(src.oldLayout, "VkImageLayout oldLayout", os, indent +1);
    Print(src.newLayout, "VkImageLayout newLayout", os, indent +1);
    Print(src.srcQueueFamilyIndex, "uint32_t srcQueueFamilyIndex", os, indent +1);
    Print(src.dstQueueFamilyIndex, "uint32_t dstQueueFamilyIndex", os, indent +1);
        PrintInterfacePointer(src.image, "VkImage image", os, indent +1);
    Print(src.subresourceRange, "VkImageSubresourceRange subresourceRange", os, indent +1);
}

template <>
inline void Print<VkImageMemoryBarrier2>(VkImageMemoryBarrier2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.srcStageMask, "VkPipelineStageFlags2 srcStageMask", os, indent +1);
    Print(src.srcAccessMask, "VkAccessFlags2 srcAccessMask", os, indent +1);
    Print(src.dstStageMask, "VkPipelineStageFlags2 dstStageMask", os, indent +1);
    Print(src.dstAccessMask, "VkAccessFlags2 dstAccessMask", os, indent +1);
    Print(src.oldLayout, "VkImageLayout oldLayout", os, indent +1);
    Print(src.newLayout, "VkImageLayout newLayout", os, indent +1);
    Print(src.srcQueueFamilyIndex, "uint32_t srcQueueFamilyIndex", os, indent +1);
    Print(src.dstQueueFamilyIndex, "uint32_t dstQueueFamilyIndex", os, indent +1);
        PrintInterfacePointer(src.image, "VkImage image", os, indent +1);
    Print(src.subresourceRange, "VkImageSubresourceRange subresourceRange", os, indent +1);
}

template <>
inline void Print<VkImageMemoryRequirementsInfo2>(VkImageMemoryRequirementsInfo2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.image, "VkImage image", os, indent +1);
}

template <>
inline void Print<VkImagePlaneMemoryRequirementsInfo>(VkImagePlaneMemoryRequirementsInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.planeAspect, "VkImageAspectFlagBits planeAspect", os, indent +1);
}

template <>
inline void Print<VkImageResolve>(VkImageResolve const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.srcSubresource, "VkImageSubresourceLayers srcSubresource", os, indent +1);
    Print(src.srcOffset, "VkOffset3D srcOffset", os, indent +1);
    Print(src.dstSubresource, "VkImageSubresourceLayers dstSubresource", os, indent +1);
    Print(src.dstOffset, "VkOffset3D dstOffset", os, indent +1);
    Print(src.extent, "VkExtent3D extent", os, indent +1);
}

template <>
inline void Print<VkImageResolve2>(VkImageResolve2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.srcSubresource, "VkImageSubresourceLayers srcSubresource", os, indent +1);
    Print(src.srcOffset, "VkOffset3D srcOffset", os, indent +1);
    Print(src.dstSubresource, "VkImageSubresourceLayers dstSubresource", os, indent +1);
    Print(src.dstOffset, "VkOffset3D dstOffset", os, indent +1);
    Print(src.extent, "VkExtent3D extent", os, indent +1);
}

template <>
inline void Print<VkImageSparseMemoryRequirementsInfo2>(VkImageSparseMemoryRequirementsInfo2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.image, "VkImage image", os, indent +1);
}

template <>
inline void Print<VkImageStencilUsageCreateInfo>(VkImageStencilUsageCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.stencilUsage, "VkImageUsageFlags stencilUsage", os, indent +1);
}

template <>
inline void Print<VkImageSubresource>(VkImageSubresource const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.aspectMask, "VkImageAspectFlags aspectMask", os, indent +1);
    Print(src.mipLevel, "uint32_t mipLevel", os, indent +1);
    Print(src.arrayLayer, "uint32_t arrayLayer", os, indent +1);
}

template <>
inline void Print<VkImageSubresource2EXT>(VkImageSubresource2EXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.imageSubresource, "VkImageSubresource imageSubresource", os, indent +1);
}

template <>
inline void Print<VkImageSubresourceLayers>(VkImageSubresourceLayers const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.aspectMask, "VkImageAspectFlags aspectMask", os, indent +1);
    Print(src.mipLevel, "uint32_t mipLevel", os, indent +1);
    Print(src.baseArrayLayer, "uint32_t baseArrayLayer", os, indent +1);
    Print(src.layerCount, "uint32_t layerCount", os, indent +1);
}

template <>
inline void Print<VkImageSubresourceRange>(VkImageSubresourceRange const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.aspectMask, "VkImageAspectFlags aspectMask", os, indent +1);
    Print(src.baseMipLevel, "uint32_t baseMipLevel", os, indent +1);
    Print(src.levelCount, "uint32_t levelCount", os, indent +1);
    Print(src.baseArrayLayer, "uint32_t baseArrayLayer", os, indent +1);
    Print(src.layerCount, "uint32_t layerCount", os, indent +1);
}

template <>
inline void Print<VkImageSwapchainCreateInfoKHR>(VkImageSwapchainCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.swapchain, "VkSwapchainKHR swapchain", os, indent +1);
}

template <>
inline void Print<VkImageViewASTCDecodeModeEXT>(VkImageViewASTCDecodeModeEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.decodeMode, "VkFormat decodeMode", os, indent +1);
}

template <>
inline void Print<VkImageViewAddressPropertiesNVX>(VkImageViewAddressPropertiesNVX const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.deviceAddress, "VkDeviceAddress deviceAddress", os, indent +1);
    Print(src.size, "VkDeviceSize size", os, indent +1);
}

template <>
inline void Print<VkImageViewCaptureDescriptorDataInfoEXT>(VkImageViewCaptureDescriptorDataInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.imageView, "VkImageView imageView", os, indent +1);
}

template <>
inline void Print<VkImageViewCreateInfo>(VkImageViewCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkImageViewCreateFlags flags", os, indent +1);
        PrintInterfacePointer(src.image, "VkImage image", os, indent +1);
    Print(src.viewType, "VkImageViewType viewType", os, indent +1);
    Print(src.format, "VkFormat format", os, indent +1);
    Print(src.components, "VkComponentMapping components", os, indent +1);
    Print(src.subresourceRange, "VkImageSubresourceRange subresourceRange", os, indent +1);
}

template <>
inline void Print<VkImageViewHandleInfoNVX>(VkImageViewHandleInfoNVX const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.imageView, "VkImageView imageView", os, indent +1);
    Print(src.descriptorType, "VkDescriptorType descriptorType", os, indent +1);
        PrintInterfacePointer(src.sampler, "VkSampler sampler", os, indent +1);
}

template <>
inline void Print<VkImageViewMinLodCreateInfoEXT>(VkImageViewMinLodCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.minLod, "float minLod", os, indent +1);
}

template <>
inline void Print<VkImageViewSampleWeightCreateInfoQCOM>(VkImageViewSampleWeightCreateInfoQCOM const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.filterCenter, "VkOffset2D filterCenter", os, indent +1);
    Print(src.filterSize, "VkExtent2D filterSize", os, indent +1);
    Print(src.numPhases, "uint32_t numPhases", os, indent +1);
}

template <>
inline void Print<VkImageViewUsageCreateInfo>(VkImageViewUsageCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.usage, "VkImageUsageFlags usage", os, indent +1);
}

template <>
inline void Print<VkImportFenceFdInfoKHR>(VkImportFenceFdInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.fence, "VkFence fence", os, indent +1);
    Print(src.flags, "VkFenceImportFlags flags", os, indent +1);
    Print(src.handleType, "VkExternalFenceHandleTypeFlagBits handleType", os, indent +1);
    Print(src.fd, "int fd", os, indent +1);
}

template <>
inline void Print<VkImportMemoryFdInfoKHR>(VkImportMemoryFdInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.handleType, "VkExternalMemoryHandleTypeFlagBits handleType", os, indent +1);
    Print(src.fd, "int fd", os, indent +1);
}

template <>
inline void Print<VkImportMemoryHostPointerInfoEXT>(VkImportMemoryHostPointerInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.handleType, "VkExternalMemoryHandleTypeFlagBits handleType", os, indent +1);
        PrintPointer(src.pHostPointer, "void * pHostPointer", os, indent +1);
}

template <>
inline void Print<VkImportSemaphoreFdInfoKHR>(VkImportSemaphoreFdInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.semaphore, "VkSemaphore semaphore", os, indent +1);
    Print(src.flags, "VkSemaphoreImportFlags flags", os, indent +1);
    Print(src.handleType, "VkExternalSemaphoreHandleTypeFlagBits handleType", os, indent +1);
    Print(src.fd, "int fd", os, indent +1);
}

template <>
inline void Print<VkIndirectCommandsLayoutCreateInfoNV>(VkIndirectCommandsLayoutCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkIndirectCommandsLayoutUsageFlagsNV flags", os, indent +1);
    Print(src.pipelineBindPoint, "VkPipelineBindPoint pipelineBindPoint", os, indent +1);
    Print(src.tokenCount, "uint32_t tokenCount", os, indent +1);
            if( src.tokenCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to tokenCount" << std::endl;
            } else {
        PrintPointer(src.pTokens, "const VkIndirectCommandsLayoutTokenNV * pTokens", os, indent +1);
            }

    Print(src.streamCount, "uint32_t streamCount", os, indent +1);
            if( src.streamCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to streamCount" << std::endl;
            } else {
        PrintPointer(src.pStreamStrides, "const uint32_t * pStreamStrides", os, indent +1);
            }

}

template <>
inline void Print<VkIndirectCommandsLayoutTokenNV>(VkIndirectCommandsLayoutTokenNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.tokenType, "VkIndirectCommandsTokenTypeNV tokenType", os, indent +1);
    Print(src.stream, "uint32_t stream", os, indent +1);
    Print(src.offset, "uint32_t offset", os, indent +1);
    Print(src.vertexBindingUnit, "uint32_t vertexBindingUnit", os, indent +1);
    Print(src.vertexDynamicStride, "VkBool32 vertexDynamicStride", os, indent +1);
        PrintInterfacePointer(src.pushconstantPipelineLayout, "VkPipelineLayout pushconstantPipelineLayout", os, indent +1);
    Print(src.pushconstantShaderStageFlags, "VkShaderStageFlags pushconstantShaderStageFlags", os, indent +1);
    Print(src.pushconstantOffset, "uint32_t pushconstantOffset", os, indent +1);
    Print(src.pushconstantSize, "uint32_t pushconstantSize", os, indent +1);
    Print(src.indirectStateFlags, "VkIndirectStateFlagsNV indirectStateFlags", os, indent +1);
    Print(src.indexTypeCount, "uint32_t indexTypeCount", os, indent +1);
            if( src.indexTypeCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to indexTypeCount" << std::endl;
            } else {
        PrintPointer(src.pIndexTypes, "const VkIndexType * pIndexTypes", os, indent +1);
            }

            if( src.indexTypeCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to indexTypeCount" << std::endl;
            } else {
        PrintPointer(src.pIndexTypeValues, "const uint32_t * pIndexTypeValues", os, indent +1);
            }

}

template <>
inline void Print<VkIndirectCommandsStreamNV>(VkIndirectCommandsStreamNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
        PrintInterfacePointer(src.buffer, "VkBuffer buffer", os, indent +1);
    Print(src.offset, "VkDeviceSize offset", os, indent +1);
}

template <>
inline void Print<VkInitializePerformanceApiInfoINTEL>(VkInitializePerformanceApiInfoINTEL const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintPointer(src.pUserData, "void * pUserData", os, indent +1);
}

template <>
inline void Print<VkInputAttachmentAspectReference>(VkInputAttachmentAspectReference const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.subpass, "uint32_t subpass", os, indent +1);
    Print(src.inputAttachmentIndex, "uint32_t inputAttachmentIndex", os, indent +1);
    Print(src.aspectMask, "VkImageAspectFlags aspectMask", os, indent +1);
}

template <>
inline void Print<VkInstanceCreateInfo>(VkInstanceCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkInstanceCreateFlags flags", os, indent +1);
        PrintPointer(src.pApplicationInfo, "const VkApplicationInfo * pApplicationInfo", os, indent +1);
    Print(src.enabledLayerCount, "uint32_t enabledLayerCount", os, indent +1);
            if( src.enabledLayerCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to enabledLayerCount" << std::endl;
            } else {
        PrintPointer(src.ppEnabledLayerNames, "const char *const * ppEnabledLayerNames", os, indent +1);
            }

    Print(src.enabledExtensionCount, "uint32_t enabledExtensionCount", os, indent +1);
            if( src.enabledExtensionCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to enabledExtensionCount" << std::endl;
            } else {
        PrintPointer(src.ppEnabledExtensionNames, "const char *const * ppEnabledExtensionNames", os, indent +1);
            }

}

template <>
inline void Print<VkLayerProperties>(VkLayerProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    PrintArray(src.layerName, 256, "char [256] layerName", os, indent + 1);
    Print(src.specVersion, "uint32_t specVersion", os, indent +1);
    Print(src.implementationVersion, "uint32_t implementationVersion", os, indent +1);
    PrintArray(src.description, 256, "char [256] description", os, indent + 1);
}

template <>
inline void Print<VkMappedMemoryRange>(VkMappedMemoryRange const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.memory, "VkDeviceMemory memory", os, indent +1);
    Print(src.offset, "VkDeviceSize offset", os, indent +1);
    Print(src.size, "VkDeviceSize size", os, indent +1);
}

template <>
inline void Print<VkMemoryAllocateFlagsInfo>(VkMemoryAllocateFlagsInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkMemoryAllocateFlags flags", os, indent +1);
    Print(src.deviceMask, "uint32_t deviceMask", os, indent +1);
}

template <>
inline void Print<VkMemoryAllocateInfo>(VkMemoryAllocateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.allocationSize, "VkDeviceSize allocationSize", os, indent +1);
    Print(src.memoryTypeIndex, "uint32_t memoryTypeIndex", os, indent +1);
}

template <>
inline void Print<VkMemoryBarrier>(VkMemoryBarrier const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.srcAccessMask, "VkAccessFlags srcAccessMask", os, indent +1);
    Print(src.dstAccessMask, "VkAccessFlags dstAccessMask", os, indent +1);
}

template <>
inline void Print<VkMemoryBarrier2>(VkMemoryBarrier2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.srcStageMask, "VkPipelineStageFlags2 srcStageMask", os, indent +1);
    Print(src.srcAccessMask, "VkAccessFlags2 srcAccessMask", os, indent +1);
    Print(src.dstStageMask, "VkPipelineStageFlags2 dstStageMask", os, indent +1);
    Print(src.dstAccessMask, "VkAccessFlags2 dstAccessMask", os, indent +1);
}

template <>
inline void Print<VkMemoryDedicatedAllocateInfo>(VkMemoryDedicatedAllocateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.image, "VkImage image", os, indent +1);
        PrintInterfacePointer(src.buffer, "VkBuffer buffer", os, indent +1);
}

template <>
inline void Print<VkMemoryDedicatedRequirements>(VkMemoryDedicatedRequirements const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.prefersDedicatedAllocation, "VkBool32 prefersDedicatedAllocation", os, indent +1);
    Print(src.requiresDedicatedAllocation, "VkBool32 requiresDedicatedAllocation", os, indent +1);
}

template <>
inline void Print<VkMemoryFdPropertiesKHR>(VkMemoryFdPropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.memoryTypeBits, "uint32_t memoryTypeBits", os, indent +1);
}

template <>
inline void Print<VkMemoryGetFdInfoKHR>(VkMemoryGetFdInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.memory, "VkDeviceMemory memory", os, indent +1);
    Print(src.handleType, "VkExternalMemoryHandleTypeFlagBits handleType", os, indent +1);
}

template <>
inline void Print<VkMemoryGetRemoteAddressInfoNV>(VkMemoryGetRemoteAddressInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.memory, "VkDeviceMemory memory", os, indent +1);
    Print(src.handleType, "VkExternalMemoryHandleTypeFlagBits handleType", os, indent +1);
}

template <>
inline void Print<VkMemoryHeap>(VkMemoryHeap const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.size, "VkDeviceSize size", os, indent +1);
    Print(src.flags, "VkMemoryHeapFlags flags", os, indent +1);
}

template <>
inline void Print<VkMemoryHostPointerPropertiesEXT>(VkMemoryHostPointerPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.memoryTypeBits, "uint32_t memoryTypeBits", os, indent +1);
}

template <>
inline void Print<VkMemoryOpaqueCaptureAddressAllocateInfo>(VkMemoryOpaqueCaptureAddressAllocateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.opaqueCaptureAddress, "uint64_t opaqueCaptureAddress", os, indent +1);
}

template <>
inline void Print<VkMemoryPriorityAllocateInfoEXT>(VkMemoryPriorityAllocateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.priority, "float priority", os, indent +1);
}

template <>
inline void Print<VkMemoryRequirements>(VkMemoryRequirements const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.size, "VkDeviceSize size", os, indent +1);
    Print(src.alignment, "VkDeviceSize alignment", os, indent +1);
    Print(src.memoryTypeBits, "uint32_t memoryTypeBits", os, indent +1);
}

template <>
inline void Print<VkMemoryRequirements2>(VkMemoryRequirements2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.memoryRequirements, "VkMemoryRequirements memoryRequirements", os, indent +1);
}

template <>
inline void Print<VkMemoryType>(VkMemoryType const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.propertyFlags, "VkMemoryPropertyFlags propertyFlags", os, indent +1);
    Print(src.heapIndex, "uint32_t heapIndex", os, indent +1);
}

template <>
inline void Print<VkMicromapBuildInfoEXT>(VkMicromapBuildInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.type, "VkMicromapTypeEXT type", os, indent +1);
    Print(src.flags, "VkBuildMicromapFlagsEXT flags", os, indent +1);
    Print(src.mode, "VkBuildMicromapModeEXT mode", os, indent +1);
        PrintInterfacePointer(src.dstMicromap, "VkMicromapEXT dstMicromap", os, indent +1);
    Print(src.usageCountsCount, "uint32_t usageCountsCount", os, indent +1);
            if( src.usageCountsCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to usageCountsCount" << std::endl;
            } else {
        PrintPointer(src.pUsageCounts, "const VkMicromapUsageEXT * pUsageCounts", os, indent +1);
            }

            if( src.usageCountsCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to usageCountsCount" << std::endl;
            } else {
        PrintPointer(src.ppUsageCounts, "const VkMicromapUsageEXT *const * ppUsageCounts", os, indent +1);
            }

        // handle union data
        // handle union scratchData
        // handle union triangleArray
    Print(src.triangleArrayStride, "VkDeviceSize triangleArrayStride", os, indent +1);
}

template <>
inline void Print<VkMicromapBuildSizesInfoEXT>(VkMicromapBuildSizesInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.micromapSize, "VkDeviceSize micromapSize", os, indent +1);
    Print(src.buildScratchSize, "VkDeviceSize buildScratchSize", os, indent +1);
    Print(src.discardable, "VkBool32 discardable", os, indent +1);
}

template <>
inline void Print<VkMicromapCreateInfoEXT>(VkMicromapCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.createFlags, "VkMicromapCreateFlagsEXT createFlags", os, indent +1);
        PrintInterfacePointer(src.buffer, "VkBuffer buffer", os, indent +1);
    Print(src.offset, "VkDeviceSize offset", os, indent +1);
    Print(src.size, "VkDeviceSize size", os, indent +1);
    Print(src.type, "VkMicromapTypeEXT type", os, indent +1);
    Print(src.deviceAddress, "VkDeviceAddress deviceAddress", os, indent +1);
}

template <>
inline void Print<VkMicromapTriangleEXT>(VkMicromapTriangleEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.dataOffset, "uint32_t dataOffset", os, indent +1);
    Print(src.subdivisionLevel, "uint16_t subdivisionLevel", os, indent +1);
    Print(src.format, "uint16_t format", os, indent +1);
}

template <>
inline void Print<VkMicromapUsageEXT>(VkMicromapUsageEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.count, "uint32_t count", os, indent +1);
    Print(src.subdivisionLevel, "uint32_t subdivisionLevel", os, indent +1);
    Print(src.format, "uint32_t format", os, indent +1);
}

template <>
inline void Print<VkMicromapVersionInfoEXT>(VkMicromapVersionInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintPointer(src.pVersionData, "const uint8_t * pVersionData", os, indent +1);
}

template <>
inline void Print<VkMultiDrawIndexedInfoEXT>(VkMultiDrawIndexedInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.firstIndex, "uint32_t firstIndex", os, indent +1);
    Print(src.indexCount, "uint32_t indexCount", os, indent +1);
    Print(src.vertexOffset, "int32_t vertexOffset", os, indent +1);
}

template <>
inline void Print<VkMultiDrawInfoEXT>(VkMultiDrawInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.firstVertex, "uint32_t firstVertex", os, indent +1);
    Print(src.vertexCount, "uint32_t vertexCount", os, indent +1);
}

template <>
inline void Print<VkMultisamplePropertiesEXT>(VkMultisamplePropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.maxSampleLocationGridSize, "VkExtent2D maxSampleLocationGridSize", os, indent +1);
}

template <>
inline void Print<VkMultisampledRenderToSingleSampledInfoEXT>(VkMultisampledRenderToSingleSampledInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.multisampledRenderToSingleSampledEnable, "VkBool32 multisampledRenderToSingleSampledEnable", os, indent +1);
    Print(src.rasterizationSamples, "VkSampleCountFlagBits rasterizationSamples", os, indent +1);
}

template <>
inline void Print<VkMultiviewPerViewAttributesInfoNVX>(VkMultiviewPerViewAttributesInfoNVX const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.perViewAttributes, "VkBool32 perViewAttributes", os, indent +1);
    Print(src.perViewAttributesPositionXOnly, "VkBool32 perViewAttributesPositionXOnly", os, indent +1);
}

template <>
inline void Print<VkMutableDescriptorTypeCreateInfoEXT>(VkMutableDescriptorTypeCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.mutableDescriptorTypeListCount, "uint32_t mutableDescriptorTypeListCount", os, indent +1);
            if( src.mutableDescriptorTypeListCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to mutableDescriptorTypeListCount" << std::endl;
            } else {
        PrintPointer(src.pMutableDescriptorTypeLists, "const VkMutableDescriptorTypeListEXT * pMutableDescriptorTypeLists", os, indent +1);
            }

}

template <>
inline void Print<VkMutableDescriptorTypeListEXT>(VkMutableDescriptorTypeListEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.descriptorTypeCount, "uint32_t descriptorTypeCount", os, indent +1);
            if( src.descriptorTypeCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to descriptorTypeCount" << std::endl;
            } else {
        PrintPointer(src.pDescriptorTypes, "const VkDescriptorType * pDescriptorTypes", os, indent +1);
            }

}

template <>
inline void Print<VkOffset2D>(VkOffset2D const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.x, "int32_t x", os, indent +1);
    Print(src.y, "int32_t y", os, indent +1);
}

template <>
inline void Print<VkOffset3D>(VkOffset3D const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.x, "int32_t x", os, indent +1);
    Print(src.y, "int32_t y", os, indent +1);
    Print(src.z, "int32_t z", os, indent +1);
}

template <>
inline void Print<VkOpaqueCaptureDescriptorDataCreateInfoEXT>(VkOpaqueCaptureDescriptorDataCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintPointer(src.opaqueCaptureDescriptorData, "const void * opaqueCaptureDescriptorData", os, indent +1);
}

template <>
inline void Print<VkOpticalFlowExecuteInfoNV>(VkOpticalFlowExecuteInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.flags, "VkOpticalFlowExecuteFlagsNV flags", os, indent +1);
    Print(src.regionCount, "uint32_t regionCount", os, indent +1);
            if( src.regionCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to regionCount" << std::endl;
            } else {
        PrintPointer(src.pRegions, "const VkRect2D * pRegions", os, indent +1);
            }

}

template <>
inline void Print<VkOpticalFlowImageFormatInfoNV>(VkOpticalFlowImageFormatInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.usage, "VkOpticalFlowUsageFlagsNV usage", os, indent +1);
}

template <>
inline void Print<VkOpticalFlowImageFormatPropertiesNV>(VkOpticalFlowImageFormatPropertiesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.format, "VkFormat format", os, indent +1);
}

template <>
inline void Print<VkOpticalFlowSessionCreateInfoNV>(VkOpticalFlowSessionCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.width, "uint32_t width", os, indent +1);
    Print(src.height, "uint32_t height", os, indent +1);
    Print(src.imageFormat, "VkFormat imageFormat", os, indent +1);
    Print(src.flowVectorFormat, "VkFormat flowVectorFormat", os, indent +1);
    Print(src.costFormat, "VkFormat costFormat", os, indent +1);
    Print(src.outputGridSize, "VkOpticalFlowGridSizeFlagsNV outputGridSize", os, indent +1);
    Print(src.hintGridSize, "VkOpticalFlowGridSizeFlagsNV hintGridSize", os, indent +1);
    Print(src.performanceLevel, "VkOpticalFlowPerformanceLevelNV performanceLevel", os, indent +1);
    Print(src.flags, "VkOpticalFlowSessionCreateFlagsNV flags", os, indent +1);
}

template <>
inline void Print<VkOpticalFlowSessionCreatePrivateDataInfoNV>(VkOpticalFlowSessionCreatePrivateDataInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.id, "uint32_t id", os, indent +1);
    Print(src.size, "uint32_t size", os, indent +1);
        PrintPointer(src.pPrivateData, "const void * pPrivateData", os, indent +1);
}

template <>
inline void Print<VkPastPresentationTimingGOOGLE>(VkPastPresentationTimingGOOGLE const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.presentID, "uint32_t presentID", os, indent +1);
    Print(src.desiredPresentTime, "uint64_t desiredPresentTime", os, indent +1);
    Print(src.actualPresentTime, "uint64_t actualPresentTime", os, indent +1);
    Print(src.earliestPresentTime, "uint64_t earliestPresentTime", os, indent +1);
    Print(src.presentMargin, "uint64_t presentMargin", os, indent +1);
}

template <>
inline void Print<VkPerformanceConfigurationAcquireInfoINTEL>(VkPerformanceConfigurationAcquireInfoINTEL const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.type, "VkPerformanceConfigurationTypeINTEL type", os, indent +1);
}

template <>
inline void Print<VkPerformanceCounterDescriptionKHR>(VkPerformanceCounterDescriptionKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.flags, "VkPerformanceCounterDescriptionFlagsKHR flags", os, indent +1);
    PrintArray(src.name, 256, "char [256] name", os, indent + 1);
    PrintArray(src.category, 256, "char [256] category", os, indent + 1);
    PrintArray(src.description, 256, "char [256] description", os, indent + 1);
}

template <>
inline void Print<VkPerformanceCounterKHR>(VkPerformanceCounterKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.unit, "VkPerformanceCounterUnitKHR unit", os, indent +1);
    Print(src.scope, "VkPerformanceCounterScopeKHR scope", os, indent +1);
    Print(src.storage, "VkPerformanceCounterStorageKHR storage", os, indent +1);
    PrintArray(src.uuid, 16, "uint8_t [16] uuid", os, indent + 1);
}

template <>
inline void Print<VkPerformanceMarkerInfoINTEL>(VkPerformanceMarkerInfoINTEL const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.marker, "uint64_t marker", os, indent +1);
}

template <>
inline void Print<VkPerformanceOverrideInfoINTEL>(VkPerformanceOverrideInfoINTEL const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.type, "VkPerformanceOverrideTypeINTEL type", os, indent +1);
    Print(src.enable, "VkBool32 enable", os, indent +1);
    Print(src.parameter, "uint64_t parameter", os, indent +1);
}

template <>
inline void Print<VkPerformanceQuerySubmitInfoKHR>(VkPerformanceQuerySubmitInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.counterPassIndex, "uint32_t counterPassIndex", os, indent +1);
}

template <>
inline void Print<VkPerformanceStreamMarkerInfoINTEL>(VkPerformanceStreamMarkerInfoINTEL const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.marker, "uint32_t marker", os, indent +1);
}

template <>
inline void Print<VkPerformanceValueINTEL>(VkPerformanceValueINTEL const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.type, "VkPerformanceValueTypeINTEL type", os, indent +1);
        // handle union data
}

template <>
inline void Print<VkPhysicalDevice16BitStorageFeatures>(VkPhysicalDevice16BitStorageFeatures const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.storageBuffer16BitAccess, "VkBool32 storageBuffer16BitAccess", os, indent +1);
    Print(src.uniformAndStorageBuffer16BitAccess, "VkBool32 uniformAndStorageBuffer16BitAccess", os, indent +1);
    Print(src.storagePushConstant16, "VkBool32 storagePushConstant16", os, indent +1);
    Print(src.storageInputOutput16, "VkBool32 storageInputOutput16", os, indent +1);
}

template <>
inline void Print<VkPhysicalDevice4444FormatsFeaturesEXT>(VkPhysicalDevice4444FormatsFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.formatA4R4G4B4, "VkBool32 formatA4R4G4B4", os, indent +1);
    Print(src.formatA4B4G4R4, "VkBool32 formatA4B4G4R4", os, indent +1);
}

template <>
inline void Print<VkPhysicalDevice8BitStorageFeatures>(VkPhysicalDevice8BitStorageFeatures const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.storageBuffer8BitAccess, "VkBool32 storageBuffer8BitAccess", os, indent +1);
    Print(src.uniformAndStorageBuffer8BitAccess, "VkBool32 uniformAndStorageBuffer8BitAccess", os, indent +1);
    Print(src.storagePushConstant8, "VkBool32 storagePushConstant8", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceASTCDecodeFeaturesEXT>(VkPhysicalDeviceASTCDecodeFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.decodeModeSharedExponent, "VkBool32 decodeModeSharedExponent", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceAccelerationStructureFeaturesKHR>(VkPhysicalDeviceAccelerationStructureFeaturesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.accelerationStructure, "VkBool32 accelerationStructure", os, indent +1);
    Print(src.accelerationStructureCaptureReplay, "VkBool32 accelerationStructureCaptureReplay", os, indent +1);
    Print(src.accelerationStructureIndirectBuild, "VkBool32 accelerationStructureIndirectBuild", os, indent +1);
    Print(src.accelerationStructureHostCommands, "VkBool32 accelerationStructureHostCommands", os, indent +1);
    Print(src.descriptorBindingAccelerationStructureUpdateAfterBind, "VkBool32 descriptorBindingAccelerationStructureUpdateAfterBind", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceAccelerationStructurePropertiesKHR>(VkPhysicalDeviceAccelerationStructurePropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.maxGeometryCount, "uint64_t maxGeometryCount", os, indent +1);
    Print(src.maxInstanceCount, "uint64_t maxInstanceCount", os, indent +1);
    Print(src.maxPrimitiveCount, "uint64_t maxPrimitiveCount", os, indent +1);
    Print(src.maxPerStageDescriptorAccelerationStructures, "uint32_t maxPerStageDescriptorAccelerationStructures", os, indent +1);
    Print(src.maxPerStageDescriptorUpdateAfterBindAccelerationStructures, "uint32_t maxPerStageDescriptorUpdateAfterBindAccelerationStructures", os, indent +1);
    Print(src.maxDescriptorSetAccelerationStructures, "uint32_t maxDescriptorSetAccelerationStructures", os, indent +1);
    Print(src.maxDescriptorSetUpdateAfterBindAccelerationStructures, "uint32_t maxDescriptorSetUpdateAfterBindAccelerationStructures", os, indent +1);
    Print(src.minAccelerationStructureScratchOffsetAlignment, "uint32_t minAccelerationStructureScratchOffsetAlignment", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceAddressBindingReportFeaturesEXT>(VkPhysicalDeviceAddressBindingReportFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.reportAddressBinding, "VkBool32 reportAddressBinding", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceAmigoProfilingFeaturesSEC>(VkPhysicalDeviceAmigoProfilingFeaturesSEC const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.amigoProfiling, "VkBool32 amigoProfiling", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT>(VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.attachmentFeedbackLoopLayout, "VkBool32 attachmentFeedbackLoopLayout", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT>(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.advancedBlendCoherentOperations, "VkBool32 advancedBlendCoherentOperations", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT>(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.advancedBlendMaxColorAttachments, "uint32_t advancedBlendMaxColorAttachments", os, indent +1);
    Print(src.advancedBlendIndependentBlend, "VkBool32 advancedBlendIndependentBlend", os, indent +1);
    Print(src.advancedBlendNonPremultipliedSrcColor, "VkBool32 advancedBlendNonPremultipliedSrcColor", os, indent +1);
    Print(src.advancedBlendNonPremultipliedDstColor, "VkBool32 advancedBlendNonPremultipliedDstColor", os, indent +1);
    Print(src.advancedBlendCorrelatedOverlap, "VkBool32 advancedBlendCorrelatedOverlap", os, indent +1);
    Print(src.advancedBlendAllOperations, "VkBool32 advancedBlendAllOperations", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT>(VkPhysicalDeviceBorderColorSwizzleFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.borderColorSwizzle, "VkBool32 borderColorSwizzle", os, indent +1);
    Print(src.borderColorSwizzleFromImage, "VkBool32 borderColorSwizzleFromImage", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceBufferDeviceAddressFeatures>(VkPhysicalDeviceBufferDeviceAddressFeatures const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.bufferDeviceAddress, "VkBool32 bufferDeviceAddress", os, indent +1);
    Print(src.bufferDeviceAddressCaptureReplay, "VkBool32 bufferDeviceAddressCaptureReplay", os, indent +1);
    Print(src.bufferDeviceAddressMultiDevice, "VkBool32 bufferDeviceAddressMultiDevice", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT>(VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.bufferDeviceAddress, "VkBool32 bufferDeviceAddress", os, indent +1);
    Print(src.bufferDeviceAddressCaptureReplay, "VkBool32 bufferDeviceAddressCaptureReplay", os, indent +1);
    Print(src.bufferDeviceAddressMultiDevice, "VkBool32 bufferDeviceAddressMultiDevice", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI>(VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.clustercullingShader, "VkBool32 clustercullingShader", os, indent +1);
    Print(src.multiviewClusterCullingShader, "VkBool32 multiviewClusterCullingShader", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI>(VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    PrintArray(src.maxWorkGroupCount, 3, "uint32_t [3] maxWorkGroupCount", os, indent + 1);
    PrintArray(src.maxWorkGroupSize, 3, "uint32_t [3] maxWorkGroupSize", os, indent + 1);
    Print(src.maxOutputClusterCount, "uint32_t maxOutputClusterCount", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceCoherentMemoryFeaturesAMD>(VkPhysicalDeviceCoherentMemoryFeaturesAMD const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.deviceCoherentMemory, "VkBool32 deviceCoherentMemory", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceColorWriteEnableFeaturesEXT>(VkPhysicalDeviceColorWriteEnableFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.colorWriteEnable, "VkBool32 colorWriteEnable", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV>(VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.computeDerivativeGroupQuads, "VkBool32 computeDerivativeGroupQuads", os, indent +1);
    Print(src.computeDerivativeGroupLinear, "VkBool32 computeDerivativeGroupLinear", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceConditionalRenderingFeaturesEXT>(VkPhysicalDeviceConditionalRenderingFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.conditionalRendering, "VkBool32 conditionalRendering", os, indent +1);
    Print(src.inheritedConditionalRendering, "VkBool32 inheritedConditionalRendering", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceConservativeRasterizationPropertiesEXT>(VkPhysicalDeviceConservativeRasterizationPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.primitiveOverestimationSize, "float primitiveOverestimationSize", os, indent +1);
    Print(src.maxExtraPrimitiveOverestimationSize, "float maxExtraPrimitiveOverestimationSize", os, indent +1);
    Print(src.extraPrimitiveOverestimationSizeGranularity, "float extraPrimitiveOverestimationSizeGranularity", os, indent +1);
    Print(src.primitiveUnderestimation, "VkBool32 primitiveUnderestimation", os, indent +1);
    Print(src.conservativePointAndLineRasterization, "VkBool32 conservativePointAndLineRasterization", os, indent +1);
    Print(src.degenerateTrianglesRasterized, "VkBool32 degenerateTrianglesRasterized", os, indent +1);
    Print(src.degenerateLinesRasterized, "VkBool32 degenerateLinesRasterized", os, indent +1);
    Print(src.fullyCoveredFragmentShaderInputVariable, "VkBool32 fullyCoveredFragmentShaderInputVariable", os, indent +1);
    Print(src.conservativeRasterizationPostDepthCoverage, "VkBool32 conservativeRasterizationPostDepthCoverage", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceCooperativeMatrixFeaturesNV>(VkPhysicalDeviceCooperativeMatrixFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.cooperativeMatrix, "VkBool32 cooperativeMatrix", os, indent +1);
    Print(src.cooperativeMatrixRobustBufferAccess, "VkBool32 cooperativeMatrixRobustBufferAccess", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceCooperativeMatrixPropertiesNV>(VkPhysicalDeviceCooperativeMatrixPropertiesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.cooperativeMatrixSupportedStages, "VkShaderStageFlags cooperativeMatrixSupportedStages", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceCopyMemoryIndirectFeaturesNV>(VkPhysicalDeviceCopyMemoryIndirectFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.indirectCopy, "VkBool32 indirectCopy", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceCopyMemoryIndirectPropertiesNV>(VkPhysicalDeviceCopyMemoryIndirectPropertiesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.supportedQueues, "VkQueueFlags supportedQueues", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceCornerSampledImageFeaturesNV>(VkPhysicalDeviceCornerSampledImageFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.cornerSampledImage, "VkBool32 cornerSampledImage", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceCoverageReductionModeFeaturesNV>(VkPhysicalDeviceCoverageReductionModeFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.coverageReductionMode, "VkBool32 coverageReductionMode", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceCustomBorderColorFeaturesEXT>(VkPhysicalDeviceCustomBorderColorFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.customBorderColors, "VkBool32 customBorderColors", os, indent +1);
    Print(src.customBorderColorWithoutFormat, "VkBool32 customBorderColorWithoutFormat", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceCustomBorderColorPropertiesEXT>(VkPhysicalDeviceCustomBorderColorPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.maxCustomBorderColorSamplers, "uint32_t maxCustomBorderColorSamplers", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>(VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.dedicatedAllocationImageAliasing, "VkBool32 dedicatedAllocationImageAliasing", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceDepthClampZeroOneFeaturesEXT>(VkPhysicalDeviceDepthClampZeroOneFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.depthClampZeroOne, "VkBool32 depthClampZeroOne", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceDepthClipControlFeaturesEXT>(VkPhysicalDeviceDepthClipControlFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.depthClipControl, "VkBool32 depthClipControl", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceDepthClipEnableFeaturesEXT>(VkPhysicalDeviceDepthClipEnableFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.depthClipEnable, "VkBool32 depthClipEnable", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceDepthStencilResolveProperties>(VkPhysicalDeviceDepthStencilResolveProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.supportedDepthResolveModes, "VkResolveModeFlags supportedDepthResolveModes", os, indent +1);
    Print(src.supportedStencilResolveModes, "VkResolveModeFlags supportedStencilResolveModes", os, indent +1);
    Print(src.independentResolveNone, "VkBool32 independentResolveNone", os, indent +1);
    Print(src.independentResolve, "VkBool32 independentResolve", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT>(VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.combinedImageSamplerDensityMapDescriptorSize, "size_t combinedImageSamplerDensityMapDescriptorSize", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceDescriptorBufferFeaturesEXT>(VkPhysicalDeviceDescriptorBufferFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.descriptorBuffer, "VkBool32 descriptorBuffer", os, indent +1);
    Print(src.descriptorBufferCaptureReplay, "VkBool32 descriptorBufferCaptureReplay", os, indent +1);
    Print(src.descriptorBufferImageLayoutIgnored, "VkBool32 descriptorBufferImageLayoutIgnored", os, indent +1);
    Print(src.descriptorBufferPushDescriptors, "VkBool32 descriptorBufferPushDescriptors", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceDescriptorBufferPropertiesEXT>(VkPhysicalDeviceDescriptorBufferPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.combinedImageSamplerDescriptorSingleArray, "VkBool32 combinedImageSamplerDescriptorSingleArray", os, indent +1);
    Print(src.bufferlessPushDescriptors, "VkBool32 bufferlessPushDescriptors", os, indent +1);
    Print(src.allowSamplerImageViewPostSubmitCreation, "VkBool32 allowSamplerImageViewPostSubmitCreation", os, indent +1);
    Print(src.descriptorBufferOffsetAlignment, "VkDeviceSize descriptorBufferOffsetAlignment", os, indent +1);
    Print(src.maxDescriptorBufferBindings, "uint32_t maxDescriptorBufferBindings", os, indent +1);
    Print(src.maxResourceDescriptorBufferBindings, "uint32_t maxResourceDescriptorBufferBindings", os, indent +1);
    Print(src.maxSamplerDescriptorBufferBindings, "uint32_t maxSamplerDescriptorBufferBindings", os, indent +1);
    Print(src.maxEmbeddedImmutableSamplerBindings, "uint32_t maxEmbeddedImmutableSamplerBindings", os, indent +1);
    Print(src.maxEmbeddedImmutableSamplers, "uint32_t maxEmbeddedImmutableSamplers", os, indent +1);
    Print(src.bufferCaptureReplayDescriptorDataSize, "size_t bufferCaptureReplayDescriptorDataSize", os, indent +1);
    Print(src.imageCaptureReplayDescriptorDataSize, "size_t imageCaptureReplayDescriptorDataSize", os, indent +1);
    Print(src.imageViewCaptureReplayDescriptorDataSize, "size_t imageViewCaptureReplayDescriptorDataSize", os, indent +1);
    Print(src.samplerCaptureReplayDescriptorDataSize, "size_t samplerCaptureReplayDescriptorDataSize", os, indent +1);
    Print(src.accelerationStructureCaptureReplayDescriptorDataSize, "size_t accelerationStructureCaptureReplayDescriptorDataSize", os, indent +1);
    Print(src.samplerDescriptorSize, "size_t samplerDescriptorSize", os, indent +1);
    Print(src.combinedImageSamplerDescriptorSize, "size_t combinedImageSamplerDescriptorSize", os, indent +1);
    Print(src.sampledImageDescriptorSize, "size_t sampledImageDescriptorSize", os, indent +1);
    Print(src.storageImageDescriptorSize, "size_t storageImageDescriptorSize", os, indent +1);
    Print(src.uniformTexelBufferDescriptorSize, "size_t uniformTexelBufferDescriptorSize", os, indent +1);
    Print(src.robustUniformTexelBufferDescriptorSize, "size_t robustUniformTexelBufferDescriptorSize", os, indent +1);
    Print(src.storageTexelBufferDescriptorSize, "size_t storageTexelBufferDescriptorSize", os, indent +1);
    Print(src.robustStorageTexelBufferDescriptorSize, "size_t robustStorageTexelBufferDescriptorSize", os, indent +1);
    Print(src.uniformBufferDescriptorSize, "size_t uniformBufferDescriptorSize", os, indent +1);
    Print(src.robustUniformBufferDescriptorSize, "size_t robustUniformBufferDescriptorSize", os, indent +1);
    Print(src.storageBufferDescriptorSize, "size_t storageBufferDescriptorSize", os, indent +1);
    Print(src.robustStorageBufferDescriptorSize, "size_t robustStorageBufferDescriptorSize", os, indent +1);
    Print(src.inputAttachmentDescriptorSize, "size_t inputAttachmentDescriptorSize", os, indent +1);
    Print(src.accelerationStructureDescriptorSize, "size_t accelerationStructureDescriptorSize", os, indent +1);
    Print(src.maxSamplerDescriptorBufferRange, "VkDeviceSize maxSamplerDescriptorBufferRange", os, indent +1);
    Print(src.maxResourceDescriptorBufferRange, "VkDeviceSize maxResourceDescriptorBufferRange", os, indent +1);
    Print(src.samplerDescriptorBufferAddressSpaceSize, "VkDeviceSize samplerDescriptorBufferAddressSpaceSize", os, indent +1);
    Print(src.resourceDescriptorBufferAddressSpaceSize, "VkDeviceSize resourceDescriptorBufferAddressSpaceSize", os, indent +1);
    Print(src.descriptorBufferAddressSpaceSize, "VkDeviceSize descriptorBufferAddressSpaceSize", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceDescriptorIndexingFeatures>(VkPhysicalDeviceDescriptorIndexingFeatures const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.shaderInputAttachmentArrayDynamicIndexing, "VkBool32 shaderInputAttachmentArrayDynamicIndexing", os, indent +1);
    Print(src.shaderUniformTexelBufferArrayDynamicIndexing, "VkBool32 shaderUniformTexelBufferArrayDynamicIndexing", os, indent +1);
    Print(src.shaderStorageTexelBufferArrayDynamicIndexing, "VkBool32 shaderStorageTexelBufferArrayDynamicIndexing", os, indent +1);
    Print(src.shaderUniformBufferArrayNonUniformIndexing, "VkBool32 shaderUniformBufferArrayNonUniformIndexing", os, indent +1);
    Print(src.shaderSampledImageArrayNonUniformIndexing, "VkBool32 shaderSampledImageArrayNonUniformIndexing", os, indent +1);
    Print(src.shaderStorageBufferArrayNonUniformIndexing, "VkBool32 shaderStorageBufferArrayNonUniformIndexing", os, indent +1);
    Print(src.shaderStorageImageArrayNonUniformIndexing, "VkBool32 shaderStorageImageArrayNonUniformIndexing", os, indent +1);
    Print(src.shaderInputAttachmentArrayNonUniformIndexing, "VkBool32 shaderInputAttachmentArrayNonUniformIndexing", os, indent +1);
    Print(src.shaderUniformTexelBufferArrayNonUniformIndexing, "VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing", os, indent +1);
    Print(src.shaderStorageTexelBufferArrayNonUniformIndexing, "VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing", os, indent +1);
    Print(src.descriptorBindingUniformBufferUpdateAfterBind, "VkBool32 descriptorBindingUniformBufferUpdateAfterBind", os, indent +1);
    Print(src.descriptorBindingSampledImageUpdateAfterBind, "VkBool32 descriptorBindingSampledImageUpdateAfterBind", os, indent +1);
    Print(src.descriptorBindingStorageImageUpdateAfterBind, "VkBool32 descriptorBindingStorageImageUpdateAfterBind", os, indent +1);
    Print(src.descriptorBindingStorageBufferUpdateAfterBind, "VkBool32 descriptorBindingStorageBufferUpdateAfterBind", os, indent +1);
    Print(src.descriptorBindingUniformTexelBufferUpdateAfterBind, "VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind", os, indent +1);
    Print(src.descriptorBindingStorageTexelBufferUpdateAfterBind, "VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind", os, indent +1);
    Print(src.descriptorBindingUpdateUnusedWhilePending, "VkBool32 descriptorBindingUpdateUnusedWhilePending", os, indent +1);
    Print(src.descriptorBindingPartiallyBound, "VkBool32 descriptorBindingPartiallyBound", os, indent +1);
    Print(src.descriptorBindingVariableDescriptorCount, "VkBool32 descriptorBindingVariableDescriptorCount", os, indent +1);
    Print(src.runtimeDescriptorArray, "VkBool32 runtimeDescriptorArray", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceDescriptorIndexingProperties>(VkPhysicalDeviceDescriptorIndexingProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.maxUpdateAfterBindDescriptorsInAllPools, "uint32_t maxUpdateAfterBindDescriptorsInAllPools", os, indent +1);
    Print(src.shaderUniformBufferArrayNonUniformIndexingNative, "VkBool32 shaderUniformBufferArrayNonUniformIndexingNative", os, indent +1);
    Print(src.shaderSampledImageArrayNonUniformIndexingNative, "VkBool32 shaderSampledImageArrayNonUniformIndexingNative", os, indent +1);
    Print(src.shaderStorageBufferArrayNonUniformIndexingNative, "VkBool32 shaderStorageBufferArrayNonUniformIndexingNative", os, indent +1);
    Print(src.shaderStorageImageArrayNonUniformIndexingNative, "VkBool32 shaderStorageImageArrayNonUniformIndexingNative", os, indent +1);
    Print(src.shaderInputAttachmentArrayNonUniformIndexingNative, "VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative", os, indent +1);
    Print(src.robustBufferAccessUpdateAfterBind, "VkBool32 robustBufferAccessUpdateAfterBind", os, indent +1);
    Print(src.quadDivergentImplicitLod, "VkBool32 quadDivergentImplicitLod", os, indent +1);
    Print(src.maxPerStageDescriptorUpdateAfterBindSamplers, "uint32_t maxPerStageDescriptorUpdateAfterBindSamplers", os, indent +1);
    Print(src.maxPerStageDescriptorUpdateAfterBindUniformBuffers, "uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers", os, indent +1);
    Print(src.maxPerStageDescriptorUpdateAfterBindStorageBuffers, "uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers", os, indent +1);
    Print(src.maxPerStageDescriptorUpdateAfterBindSampledImages, "uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages", os, indent +1);
    Print(src.maxPerStageDescriptorUpdateAfterBindStorageImages, "uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages", os, indent +1);
    Print(src.maxPerStageDescriptorUpdateAfterBindInputAttachments, "uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments", os, indent +1);
    Print(src.maxPerStageUpdateAfterBindResources, "uint32_t maxPerStageUpdateAfterBindResources", os, indent +1);
    Print(src.maxDescriptorSetUpdateAfterBindSamplers, "uint32_t maxDescriptorSetUpdateAfterBindSamplers", os, indent +1);
    Print(src.maxDescriptorSetUpdateAfterBindUniformBuffers, "uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers", os, indent +1);
    Print(src.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, "uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", os, indent +1);
    Print(src.maxDescriptorSetUpdateAfterBindStorageBuffers, "uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers", os, indent +1);
    Print(src.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, "uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", os, indent +1);
    Print(src.maxDescriptorSetUpdateAfterBindSampledImages, "uint32_t maxDescriptorSetUpdateAfterBindSampledImages", os, indent +1);
    Print(src.maxDescriptorSetUpdateAfterBindStorageImages, "uint32_t maxDescriptorSetUpdateAfterBindStorageImages", os, indent +1);
    Print(src.maxDescriptorSetUpdateAfterBindInputAttachments, "uint32_t maxDescriptorSetUpdateAfterBindInputAttachments", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE>(VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.descriptorSetHostMapping, "VkBool32 descriptorSetHostMapping", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV>(VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.deviceGeneratedCommands, "VkBool32 deviceGeneratedCommands", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV>(VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.maxGraphicsShaderGroupCount, "uint32_t maxGraphicsShaderGroupCount", os, indent +1);
    Print(src.maxIndirectSequenceCount, "uint32_t maxIndirectSequenceCount", os, indent +1);
    Print(src.maxIndirectCommandsTokenCount, "uint32_t maxIndirectCommandsTokenCount", os, indent +1);
    Print(src.maxIndirectCommandsStreamCount, "uint32_t maxIndirectCommandsStreamCount", os, indent +1);
    Print(src.maxIndirectCommandsTokenOffset, "uint32_t maxIndirectCommandsTokenOffset", os, indent +1);
    Print(src.maxIndirectCommandsStreamStride, "uint32_t maxIndirectCommandsStreamStride", os, indent +1);
    Print(src.minSequencesCountBufferOffsetAlignment, "uint32_t minSequencesCountBufferOffsetAlignment", os, indent +1);
    Print(src.minSequencesIndexBufferOffsetAlignment, "uint32_t minSequencesIndexBufferOffsetAlignment", os, indent +1);
    Print(src.minIndirectCommandsBufferOffsetAlignment, "uint32_t minIndirectCommandsBufferOffsetAlignment", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT>(VkPhysicalDeviceDeviceMemoryReportFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.deviceMemoryReport, "VkBool32 deviceMemoryReport", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceDiagnosticsConfigFeaturesNV>(VkPhysicalDeviceDiagnosticsConfigFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.diagnosticsConfig, "VkBool32 diagnosticsConfig", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceDiscardRectanglePropertiesEXT>(VkPhysicalDeviceDiscardRectanglePropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.maxDiscardRectangles, "uint32_t maxDiscardRectangles", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceDriverProperties>(VkPhysicalDeviceDriverProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.driverID, "VkDriverId driverID", os, indent +1);
    PrintArray(src.driverName, 256, "char [256] driverName", os, indent + 1);
    PrintArray(src.driverInfo, 256, "char [256] driverInfo", os, indent + 1);
    Print(src.conformanceVersion, "VkConformanceVersion conformanceVersion", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceDrmPropertiesEXT>(VkPhysicalDeviceDrmPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.hasPrimary, "VkBool32 hasPrimary", os, indent +1);
    Print(src.hasRender, "VkBool32 hasRender", os, indent +1);
    Print(src.primaryMajor, "int64_t primaryMajor", os, indent +1);
    Print(src.primaryMinor, "int64_t primaryMinor", os, indent +1);
    Print(src.renderMajor, "int64_t renderMajor", os, indent +1);
    Print(src.renderMinor, "int64_t renderMinor", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceDynamicRenderingFeatures>(VkPhysicalDeviceDynamicRenderingFeatures const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.dynamicRendering, "VkBool32 dynamicRendering", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceExclusiveScissorFeaturesNV>(VkPhysicalDeviceExclusiveScissorFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.exclusiveScissor, "VkBool32 exclusiveScissor", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT>(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.extendedDynamicState2, "VkBool32 extendedDynamicState2", os, indent +1);
    Print(src.extendedDynamicState2LogicOp, "VkBool32 extendedDynamicState2LogicOp", os, indent +1);
    Print(src.extendedDynamicState2PatchControlPoints, "VkBool32 extendedDynamicState2PatchControlPoints", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.extendedDynamicState3TessellationDomainOrigin, "VkBool32 extendedDynamicState3TessellationDomainOrigin", os, indent +1);
    Print(src.extendedDynamicState3DepthClampEnable, "VkBool32 extendedDynamicState3DepthClampEnable", os, indent +1);
    Print(src.extendedDynamicState3PolygonMode, "VkBool32 extendedDynamicState3PolygonMode", os, indent +1);
    Print(src.extendedDynamicState3RasterizationSamples, "VkBool32 extendedDynamicState3RasterizationSamples", os, indent +1);
    Print(src.extendedDynamicState3SampleMask, "VkBool32 extendedDynamicState3SampleMask", os, indent +1);
    Print(src.extendedDynamicState3AlphaToCoverageEnable, "VkBool32 extendedDynamicState3AlphaToCoverageEnable", os, indent +1);
    Print(src.extendedDynamicState3AlphaToOneEnable, "VkBool32 extendedDynamicState3AlphaToOneEnable", os, indent +1);
    Print(src.extendedDynamicState3LogicOpEnable, "VkBool32 extendedDynamicState3LogicOpEnable", os, indent +1);
    Print(src.extendedDynamicState3ColorBlendEnable, "VkBool32 extendedDynamicState3ColorBlendEnable", os, indent +1);
    Print(src.extendedDynamicState3ColorBlendEquation, "VkBool32 extendedDynamicState3ColorBlendEquation", os, indent +1);
    Print(src.extendedDynamicState3ColorWriteMask, "VkBool32 extendedDynamicState3ColorWriteMask", os, indent +1);
    Print(src.extendedDynamicState3RasterizationStream, "VkBool32 extendedDynamicState3RasterizationStream", os, indent +1);
    Print(src.extendedDynamicState3ConservativeRasterizationMode, "VkBool32 extendedDynamicState3ConservativeRasterizationMode", os, indent +1);
    Print(src.extendedDynamicState3ExtraPrimitiveOverestimationSize, "VkBool32 extendedDynamicState3ExtraPrimitiveOverestimationSize", os, indent +1);
    Print(src.extendedDynamicState3DepthClipEnable, "VkBool32 extendedDynamicState3DepthClipEnable", os, indent +1);
    Print(src.extendedDynamicState3SampleLocationsEnable, "VkBool32 extendedDynamicState3SampleLocationsEnable", os, indent +1);
    Print(src.extendedDynamicState3ColorBlendAdvanced, "VkBool32 extendedDynamicState3ColorBlendAdvanced", os, indent +1);
    Print(src.extendedDynamicState3ProvokingVertexMode, "VkBool32 extendedDynamicState3ProvokingVertexMode", os, indent +1);
    Print(src.extendedDynamicState3LineRasterizationMode, "VkBool32 extendedDynamicState3LineRasterizationMode", os, indent +1);
    Print(src.extendedDynamicState3LineStippleEnable, "VkBool32 extendedDynamicState3LineStippleEnable", os, indent +1);
    Print(src.extendedDynamicState3DepthClipNegativeOneToOne, "VkBool32 extendedDynamicState3DepthClipNegativeOneToOne", os, indent +1);
    Print(src.extendedDynamicState3ViewportWScalingEnable, "VkBool32 extendedDynamicState3ViewportWScalingEnable", os, indent +1);
    Print(src.extendedDynamicState3ViewportSwizzle, "VkBool32 extendedDynamicState3ViewportSwizzle", os, indent +1);
    Print(src.extendedDynamicState3CoverageToColorEnable, "VkBool32 extendedDynamicState3CoverageToColorEnable", os, indent +1);
    Print(src.extendedDynamicState3CoverageToColorLocation, "VkBool32 extendedDynamicState3CoverageToColorLocation", os, indent +1);
    Print(src.extendedDynamicState3CoverageModulationMode, "VkBool32 extendedDynamicState3CoverageModulationMode", os, indent +1);
    Print(src.extendedDynamicState3CoverageModulationTableEnable, "VkBool32 extendedDynamicState3CoverageModulationTableEnable", os, indent +1);
    Print(src.extendedDynamicState3CoverageModulationTable, "VkBool32 extendedDynamicState3CoverageModulationTable", os, indent +1);
    Print(src.extendedDynamicState3CoverageReductionMode, "VkBool32 extendedDynamicState3CoverageReductionMode", os, indent +1);
    Print(src.extendedDynamicState3RepresentativeFragmentTestEnable, "VkBool32 extendedDynamicState3RepresentativeFragmentTestEnable", os, indent +1);
    Print(src.extendedDynamicState3ShadingRateImageEnable, "VkBool32 extendedDynamicState3ShadingRateImageEnable", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceExtendedDynamicState3PropertiesEXT>(VkPhysicalDeviceExtendedDynamicState3PropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.dynamicPrimitiveTopologyUnrestricted, "VkBool32 dynamicPrimitiveTopologyUnrestricted", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT>(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.extendedDynamicState, "VkBool32 extendedDynamicState", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceExternalBufferInfo>(VkPhysicalDeviceExternalBufferInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkBufferCreateFlags flags", os, indent +1);
    Print(src.usage, "VkBufferUsageFlags usage", os, indent +1);
    Print(src.handleType, "VkExternalMemoryHandleTypeFlagBits handleType", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceExternalFenceInfo>(VkPhysicalDeviceExternalFenceInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.handleType, "VkExternalFenceHandleTypeFlagBits handleType", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceExternalImageFormatInfo>(VkPhysicalDeviceExternalImageFormatInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.handleType, "VkExternalMemoryHandleTypeFlagBits handleType", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceExternalMemoryHostPropertiesEXT>(VkPhysicalDeviceExternalMemoryHostPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.minImportedHostPointerAlignment, "VkDeviceSize minImportedHostPointerAlignment", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceExternalMemoryRDMAFeaturesNV>(VkPhysicalDeviceExternalMemoryRDMAFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.externalMemoryRDMA, "VkBool32 externalMemoryRDMA", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceExternalSemaphoreInfo>(VkPhysicalDeviceExternalSemaphoreInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.handleType, "VkExternalSemaphoreHandleTypeFlagBits handleType", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceFaultFeaturesEXT>(VkPhysicalDeviceFaultFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.deviceFault, "VkBool32 deviceFault", os, indent +1);
    Print(src.deviceFaultVendorBinary, "VkBool32 deviceFaultVendorBinary", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceFeatures>(VkPhysicalDeviceFeatures const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.robustBufferAccess, "VkBool32 robustBufferAccess", os, indent +1);
    Print(src.fullDrawIndexUint32, "VkBool32 fullDrawIndexUint32", os, indent +1);
    Print(src.imageCubeArray, "VkBool32 imageCubeArray", os, indent +1);
    Print(src.independentBlend, "VkBool32 independentBlend", os, indent +1);
    Print(src.geometryShader, "VkBool32 geometryShader", os, indent +1);
    Print(src.tessellationShader, "VkBool32 tessellationShader", os, indent +1);
    Print(src.sampleRateShading, "VkBool32 sampleRateShading", os, indent +1);
    Print(src.dualSrcBlend, "VkBool32 dualSrcBlend", os, indent +1);
    Print(src.logicOp, "VkBool32 logicOp", os, indent +1);
    Print(src.multiDrawIndirect, "VkBool32 multiDrawIndirect", os, indent +1);
    Print(src.drawIndirectFirstInstance, "VkBool32 drawIndirectFirstInstance", os, indent +1);
    Print(src.depthClamp, "VkBool32 depthClamp", os, indent +1);
    Print(src.depthBiasClamp, "VkBool32 depthBiasClamp", os, indent +1);
    Print(src.fillModeNonSolid, "VkBool32 fillModeNonSolid", os, indent +1);
    Print(src.depthBounds, "VkBool32 depthBounds", os, indent +1);
    Print(src.wideLines, "VkBool32 wideLines", os, indent +1);
    Print(src.largePoints, "VkBool32 largePoints", os, indent +1);
    Print(src.alphaToOne, "VkBool32 alphaToOne", os, indent +1);
    Print(src.multiViewport, "VkBool32 multiViewport", os, indent +1);
    Print(src.samplerAnisotropy, "VkBool32 samplerAnisotropy", os, indent +1);
    Print(src.textureCompressionETC2, "VkBool32 textureCompressionETC2", os, indent +1);
    Print(src.textureCompressionASTC_LDR, "VkBool32 textureCompressionASTC_LDR", os, indent +1);
    Print(src.textureCompressionBC, "VkBool32 textureCompressionBC", os, indent +1);
    Print(src.occlusionQueryPrecise, "VkBool32 occlusionQueryPrecise", os, indent +1);
    Print(src.pipelineStatisticsQuery, "VkBool32 pipelineStatisticsQuery", os, indent +1);
    Print(src.vertexPipelineStoresAndAtomics, "VkBool32 vertexPipelineStoresAndAtomics", os, indent +1);
    Print(src.fragmentStoresAndAtomics, "VkBool32 fragmentStoresAndAtomics", os, indent +1);
    Print(src.shaderTessellationAndGeometryPointSize, "VkBool32 shaderTessellationAndGeometryPointSize", os, indent +1);
    Print(src.shaderImageGatherExtended, "VkBool32 shaderImageGatherExtended", os, indent +1);
    Print(src.shaderStorageImageExtendedFormats, "VkBool32 shaderStorageImageExtendedFormats", os, indent +1);
    Print(src.shaderStorageImageMultisample, "VkBool32 shaderStorageImageMultisample", os, indent +1);
    Print(src.shaderStorageImageReadWithoutFormat, "VkBool32 shaderStorageImageReadWithoutFormat", os, indent +1);
    Print(src.shaderStorageImageWriteWithoutFormat, "VkBool32 shaderStorageImageWriteWithoutFormat", os, indent +1);
    Print(src.shaderUniformBufferArrayDynamicIndexing, "VkBool32 shaderUniformBufferArrayDynamicIndexing", os, indent +1);
    Print(src.shaderSampledImageArrayDynamicIndexing, "VkBool32 shaderSampledImageArrayDynamicIndexing", os, indent +1);
    Print(src.shaderStorageBufferArrayDynamicIndexing, "VkBool32 shaderStorageBufferArrayDynamicIndexing", os, indent +1);
    Print(src.shaderStorageImageArrayDynamicIndexing, "VkBool32 shaderStorageImageArrayDynamicIndexing", os, indent +1);
    Print(src.shaderClipDistance, "VkBool32 shaderClipDistance", os, indent +1);
    Print(src.shaderCullDistance, "VkBool32 shaderCullDistance", os, indent +1);
    Print(src.shaderFloat64, "VkBool32 shaderFloat64", os, indent +1);
    Print(src.shaderInt64, "VkBool32 shaderInt64", os, indent +1);
    Print(src.shaderInt16, "VkBool32 shaderInt16", os, indent +1);
    Print(src.shaderResourceResidency, "VkBool32 shaderResourceResidency", os, indent +1);
    Print(src.shaderResourceMinLod, "VkBool32 shaderResourceMinLod", os, indent +1);
    Print(src.sparseBinding, "VkBool32 sparseBinding", os, indent +1);
    Print(src.sparseResidencyBuffer, "VkBool32 sparseResidencyBuffer", os, indent +1);
    Print(src.sparseResidencyImage2D, "VkBool32 sparseResidencyImage2D", os, indent +1);
    Print(src.sparseResidencyImage3D, "VkBool32 sparseResidencyImage3D", os, indent +1);
    Print(src.sparseResidency2Samples, "VkBool32 sparseResidency2Samples", os, indent +1);
    Print(src.sparseResidency4Samples, "VkBool32 sparseResidency4Samples", os, indent +1);
    Print(src.sparseResidency8Samples, "VkBool32 sparseResidency8Samples", os, indent +1);
    Print(src.sparseResidency16Samples, "VkBool32 sparseResidency16Samples", os, indent +1);
    Print(src.sparseResidencyAliased, "VkBool32 sparseResidencyAliased", os, indent +1);
    Print(src.variableMultisampleRate, "VkBool32 variableMultisampleRate", os, indent +1);
    Print(src.inheritedQueries, "VkBool32 inheritedQueries", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceFeatures2>(VkPhysicalDeviceFeatures2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.features, "VkPhysicalDeviceFeatures features", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceFloatControlsProperties>(VkPhysicalDeviceFloatControlsProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.denormBehaviorIndependence, "VkShaderFloatControlsIndependence denormBehaviorIndependence", os, indent +1);
    Print(src.roundingModeIndependence, "VkShaderFloatControlsIndependence roundingModeIndependence", os, indent +1);
    Print(src.shaderSignedZeroInfNanPreserveFloat16, "VkBool32 shaderSignedZeroInfNanPreserveFloat16", os, indent +1);
    Print(src.shaderSignedZeroInfNanPreserveFloat32, "VkBool32 shaderSignedZeroInfNanPreserveFloat32", os, indent +1);
    Print(src.shaderSignedZeroInfNanPreserveFloat64, "VkBool32 shaderSignedZeroInfNanPreserveFloat64", os, indent +1);
    Print(src.shaderDenormPreserveFloat16, "VkBool32 shaderDenormPreserveFloat16", os, indent +1);
    Print(src.shaderDenormPreserveFloat32, "VkBool32 shaderDenormPreserveFloat32", os, indent +1);
    Print(src.shaderDenormPreserveFloat64, "VkBool32 shaderDenormPreserveFloat64", os, indent +1);
    Print(src.shaderDenormFlushToZeroFloat16, "VkBool32 shaderDenormFlushToZeroFloat16", os, indent +1);
    Print(src.shaderDenormFlushToZeroFloat32, "VkBool32 shaderDenormFlushToZeroFloat32", os, indent +1);
    Print(src.shaderDenormFlushToZeroFloat64, "VkBool32 shaderDenormFlushToZeroFloat64", os, indent +1);
    Print(src.shaderRoundingModeRTEFloat16, "VkBool32 shaderRoundingModeRTEFloat16", os, indent +1);
    Print(src.shaderRoundingModeRTEFloat32, "VkBool32 shaderRoundingModeRTEFloat32", os, indent +1);
    Print(src.shaderRoundingModeRTEFloat64, "VkBool32 shaderRoundingModeRTEFloat64", os, indent +1);
    Print(src.shaderRoundingModeRTZFloat16, "VkBool32 shaderRoundingModeRTZFloat16", os, indent +1);
    Print(src.shaderRoundingModeRTZFloat32, "VkBool32 shaderRoundingModeRTZFloat32", os, indent +1);
    Print(src.shaderRoundingModeRTZFloat64, "VkBool32 shaderRoundingModeRTZFloat64", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT>(VkPhysicalDeviceFragmentDensityMap2FeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.fragmentDensityMapDeferred, "VkBool32 fragmentDensityMapDeferred", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT>(VkPhysicalDeviceFragmentDensityMap2PropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.subsampledLoads, "VkBool32 subsampledLoads", os, indent +1);
    Print(src.subsampledCoarseReconstructionEarlyAccess, "VkBool32 subsampledCoarseReconstructionEarlyAccess", os, indent +1);
    Print(src.maxSubsampledArrayLayers, "uint32_t maxSubsampledArrayLayers", os, indent +1);
    Print(src.maxDescriptorSetSubsampledSamplers, "uint32_t maxDescriptorSetSubsampledSamplers", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceFragmentDensityMapFeaturesEXT>(VkPhysicalDeviceFragmentDensityMapFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.fragmentDensityMap, "VkBool32 fragmentDensityMap", os, indent +1);
    Print(src.fragmentDensityMapDynamic, "VkBool32 fragmentDensityMapDynamic", os, indent +1);
    Print(src.fragmentDensityMapNonSubsampledImages, "VkBool32 fragmentDensityMapNonSubsampledImages", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>(VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.fragmentDensityMapOffset, "VkBool32 fragmentDensityMapOffset", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>(VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.fragmentDensityOffsetGranularity, "VkExtent2D fragmentDensityOffsetGranularity", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceFragmentDensityMapPropertiesEXT>(VkPhysicalDeviceFragmentDensityMapPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.minFragmentDensityTexelSize, "VkExtent2D minFragmentDensityTexelSize", os, indent +1);
    Print(src.maxFragmentDensityTexelSize, "VkExtent2D maxFragmentDensityTexelSize", os, indent +1);
    Print(src.fragmentDensityInvocations, "VkBool32 fragmentDensityInvocations", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR>(VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.fragmentShaderBarycentric, "VkBool32 fragmentShaderBarycentric", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR>(VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.triStripVertexOrderIndependentOfProvokingVertex, "VkBool32 triStripVertexOrderIndependentOfProvokingVertex", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT>(VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.fragmentShaderSampleInterlock, "VkBool32 fragmentShaderSampleInterlock", os, indent +1);
    Print(src.fragmentShaderPixelInterlock, "VkBool32 fragmentShaderPixelInterlock", os, indent +1);
    Print(src.fragmentShaderShadingRateInterlock, "VkBool32 fragmentShaderShadingRateInterlock", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV>(VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.fragmentShadingRateEnums, "VkBool32 fragmentShadingRateEnums", os, indent +1);
    Print(src.supersampleFragmentShadingRates, "VkBool32 supersampleFragmentShadingRates", os, indent +1);
    Print(src.noInvocationFragmentShadingRates, "VkBool32 noInvocationFragmentShadingRates", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV>(VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.maxFragmentShadingRateInvocationCount, "VkSampleCountFlagBits maxFragmentShadingRateInvocationCount", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceFragmentShadingRateFeaturesKHR>(VkPhysicalDeviceFragmentShadingRateFeaturesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.pipelineFragmentShadingRate, "VkBool32 pipelineFragmentShadingRate", os, indent +1);
    Print(src.primitiveFragmentShadingRate, "VkBool32 primitiveFragmentShadingRate", os, indent +1);
    Print(src.attachmentFragmentShadingRate, "VkBool32 attachmentFragmentShadingRate", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceFragmentShadingRateKHR>(VkPhysicalDeviceFragmentShadingRateKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.sampleCounts, "VkSampleCountFlags sampleCounts", os, indent +1);
    Print(src.fragmentSize, "VkExtent2D fragmentSize", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceFragmentShadingRatePropertiesKHR>(VkPhysicalDeviceFragmentShadingRatePropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.minFragmentShadingRateAttachmentTexelSize, "VkExtent2D minFragmentShadingRateAttachmentTexelSize", os, indent +1);
    Print(src.maxFragmentShadingRateAttachmentTexelSize, "VkExtent2D maxFragmentShadingRateAttachmentTexelSize", os, indent +1);
    Print(src.maxFragmentShadingRateAttachmentTexelSizeAspectRatio, "uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio", os, indent +1);
    Print(src.primitiveFragmentShadingRateWithMultipleViewports, "VkBool32 primitiveFragmentShadingRateWithMultipleViewports", os, indent +1);
    Print(src.layeredShadingRateAttachments, "VkBool32 layeredShadingRateAttachments", os, indent +1);
    Print(src.fragmentShadingRateNonTrivialCombinerOps, "VkBool32 fragmentShadingRateNonTrivialCombinerOps", os, indent +1);
    Print(src.maxFragmentSize, "VkExtent2D maxFragmentSize", os, indent +1);
    Print(src.maxFragmentSizeAspectRatio, "uint32_t maxFragmentSizeAspectRatio", os, indent +1);
    Print(src.maxFragmentShadingRateCoverageSamples, "uint32_t maxFragmentShadingRateCoverageSamples", os, indent +1);
    Print(src.maxFragmentShadingRateRasterizationSamples, "VkSampleCountFlagBits maxFragmentShadingRateRasterizationSamples", os, indent +1);
    Print(src.fragmentShadingRateWithShaderDepthStencilWrites, "VkBool32 fragmentShadingRateWithShaderDepthStencilWrites", os, indent +1);
    Print(src.fragmentShadingRateWithSampleMask, "VkBool32 fragmentShadingRateWithSampleMask", os, indent +1);
    Print(src.fragmentShadingRateWithShaderSampleMask, "VkBool32 fragmentShadingRateWithShaderSampleMask", os, indent +1);
    Print(src.fragmentShadingRateWithConservativeRasterization, "VkBool32 fragmentShadingRateWithConservativeRasterization", os, indent +1);
    Print(src.fragmentShadingRateWithFragmentShaderInterlock, "VkBool32 fragmentShadingRateWithFragmentShaderInterlock", os, indent +1);
    Print(src.fragmentShadingRateWithCustomSampleLocations, "VkBool32 fragmentShadingRateWithCustomSampleLocations", os, indent +1);
    Print(src.fragmentShadingRateStrictMultiplyCombiner, "VkBool32 fragmentShadingRateStrictMultiplyCombiner", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR>(VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.globalPriorityQuery, "VkBool32 globalPriorityQuery", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT>(VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.graphicsPipelineLibrary, "VkBool32 graphicsPipelineLibrary", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT>(VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.graphicsPipelineLibraryFastLinking, "VkBool32 graphicsPipelineLibraryFastLinking", os, indent +1);
    Print(src.graphicsPipelineLibraryIndependentInterpolationDecoration, "VkBool32 graphicsPipelineLibraryIndependentInterpolationDecoration", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceGroupProperties>(VkPhysicalDeviceGroupProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.physicalDeviceCount, "uint32_t physicalDeviceCount", os, indent +1);
        PrintPointer(src.physicalDevices, "VkPhysicalDevice [32] physicalDevices", os, indent +1);
    Print(src.subsetAllocation, "VkBool32 subsetAllocation", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceHostQueryResetFeatures>(VkPhysicalDeviceHostQueryResetFeatures const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.hostQueryReset, "VkBool32 hostQueryReset", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceIDProperties>(VkPhysicalDeviceIDProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    PrintArray(src.deviceUUID, 16, "uint8_t [16] deviceUUID", os, indent + 1);
    PrintArray(src.driverUUID, 16, "uint8_t [16] driverUUID", os, indent + 1);
    PrintArray(src.deviceLUID, 8, "uint8_t [8] deviceLUID", os, indent + 1);
    Print(src.deviceNodeMask, "uint32_t deviceNodeMask", os, indent +1);
    Print(src.deviceLUIDValid, "VkBool32 deviceLUIDValid", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT>(VkPhysicalDeviceImage2DViewOf3DFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.image2DViewOf3D, "VkBool32 image2DViewOf3D", os, indent +1);
    Print(src.sampler2DViewOf3D, "VkBool32 sampler2DViewOf3D", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceImageCompressionControlFeaturesEXT>(VkPhysicalDeviceImageCompressionControlFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.imageCompressionControl, "VkBool32 imageCompressionControl", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT>(VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.imageCompressionControlSwapchain, "VkBool32 imageCompressionControlSwapchain", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceImageDrmFormatModifierInfoEXT>(VkPhysicalDeviceImageDrmFormatModifierInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.drmFormatModifier, "uint64_t drmFormatModifier", os, indent +1);
    Print(src.sharingMode, "VkSharingMode sharingMode", os, indent +1);
    Print(src.queueFamilyIndexCount, "uint32_t queueFamilyIndexCount", os, indent +1);
            if( src.queueFamilyIndexCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to queueFamilyIndexCount" << std::endl;
            } else {
        PrintPointer(src.pQueueFamilyIndices, "const uint32_t * pQueueFamilyIndices", os, indent +1);
            }

}

template <>
inline void Print<VkPhysicalDeviceImageFormatInfo2>(VkPhysicalDeviceImageFormatInfo2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.format, "VkFormat format", os, indent +1);
    Print(src.type, "VkImageType type", os, indent +1);
    Print(src.tiling, "VkImageTiling tiling", os, indent +1);
    Print(src.usage, "VkImageUsageFlags usage", os, indent +1);
    Print(src.flags, "VkImageCreateFlags flags", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceImageProcessingFeaturesQCOM>(VkPhysicalDeviceImageProcessingFeaturesQCOM const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.textureSampleWeighted, "VkBool32 textureSampleWeighted", os, indent +1);
    Print(src.textureBoxFilter, "VkBool32 textureBoxFilter", os, indent +1);
    Print(src.textureBlockMatch, "VkBool32 textureBlockMatch", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceImageProcessingPropertiesQCOM>(VkPhysicalDeviceImageProcessingPropertiesQCOM const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.maxWeightFilterPhases, "uint32_t maxWeightFilterPhases", os, indent +1);
    Print(src.maxWeightFilterDimension, "VkExtent2D maxWeightFilterDimension", os, indent +1);
    Print(src.maxBlockMatchRegion, "VkExtent2D maxBlockMatchRegion", os, indent +1);
    Print(src.maxBoxFilterBlockSize, "VkExtent2D maxBoxFilterBlockSize", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceImageRobustnessFeatures>(VkPhysicalDeviceImageRobustnessFeatures const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.robustImageAccess, "VkBool32 robustImageAccess", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceImageViewImageFormatInfoEXT>(VkPhysicalDeviceImageViewImageFormatInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.imageViewType, "VkImageViewType imageViewType", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceImageViewMinLodFeaturesEXT>(VkPhysicalDeviceImageViewMinLodFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.minLod, "VkBool32 minLod", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceImagelessFramebufferFeatures>(VkPhysicalDeviceImagelessFramebufferFeatures const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.imagelessFramebuffer, "VkBool32 imagelessFramebuffer", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceIndexTypeUint8FeaturesEXT>(VkPhysicalDeviceIndexTypeUint8FeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.indexTypeUint8, "VkBool32 indexTypeUint8", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceInheritedViewportScissorFeaturesNV>(VkPhysicalDeviceInheritedViewportScissorFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.inheritedViewportScissor2D, "VkBool32 inheritedViewportScissor2D", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceInlineUniformBlockFeatures>(VkPhysicalDeviceInlineUniformBlockFeatures const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.inlineUniformBlock, "VkBool32 inlineUniformBlock", os, indent +1);
    Print(src.descriptorBindingInlineUniformBlockUpdateAfterBind, "VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceInlineUniformBlockProperties>(VkPhysicalDeviceInlineUniformBlockProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.maxInlineUniformBlockSize, "uint32_t maxInlineUniformBlockSize", os, indent +1);
    Print(src.maxPerStageDescriptorInlineUniformBlocks, "uint32_t maxPerStageDescriptorInlineUniformBlocks", os, indent +1);
    Print(src.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks, "uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks", os, indent +1);
    Print(src.maxDescriptorSetInlineUniformBlocks, "uint32_t maxDescriptorSetInlineUniformBlocks", os, indent +1);
    Print(src.maxDescriptorSetUpdateAfterBindInlineUniformBlocks, "uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceInvocationMaskFeaturesHUAWEI>(VkPhysicalDeviceInvocationMaskFeaturesHUAWEI const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.invocationMask, "VkBool32 invocationMask", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceLegacyDitheringFeaturesEXT>(VkPhysicalDeviceLegacyDitheringFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.legacyDithering, "VkBool32 legacyDithering", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceLimits>(VkPhysicalDeviceLimits const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.maxImageDimension1D, "uint32_t maxImageDimension1D", os, indent +1);
    Print(src.maxImageDimension2D, "uint32_t maxImageDimension2D", os, indent +1);
    Print(src.maxImageDimension3D, "uint32_t maxImageDimension3D", os, indent +1);
    Print(src.maxImageDimensionCube, "uint32_t maxImageDimensionCube", os, indent +1);
    Print(src.maxImageArrayLayers, "uint32_t maxImageArrayLayers", os, indent +1);
    Print(src.maxTexelBufferElements, "uint32_t maxTexelBufferElements", os, indent +1);
    Print(src.maxUniformBufferRange, "uint32_t maxUniformBufferRange", os, indent +1);
    Print(src.maxStorageBufferRange, "uint32_t maxStorageBufferRange", os, indent +1);
    Print(src.maxPushConstantsSize, "uint32_t maxPushConstantsSize", os, indent +1);
    Print(src.maxMemoryAllocationCount, "uint32_t maxMemoryAllocationCount", os, indent +1);
    Print(src.maxSamplerAllocationCount, "uint32_t maxSamplerAllocationCount", os, indent +1);
    Print(src.bufferImageGranularity, "VkDeviceSize bufferImageGranularity", os, indent +1);
    Print(src.sparseAddressSpaceSize, "VkDeviceSize sparseAddressSpaceSize", os, indent +1);
    Print(src.maxBoundDescriptorSets, "uint32_t maxBoundDescriptorSets", os, indent +1);
    Print(src.maxPerStageDescriptorSamplers, "uint32_t maxPerStageDescriptorSamplers", os, indent +1);
    Print(src.maxPerStageDescriptorUniformBuffers, "uint32_t maxPerStageDescriptorUniformBuffers", os, indent +1);
    Print(src.maxPerStageDescriptorStorageBuffers, "uint32_t maxPerStageDescriptorStorageBuffers", os, indent +1);
    Print(src.maxPerStageDescriptorSampledImages, "uint32_t maxPerStageDescriptorSampledImages", os, indent +1);
    Print(src.maxPerStageDescriptorStorageImages, "uint32_t maxPerStageDescriptorStorageImages", os, indent +1);
    Print(src.maxPerStageDescriptorInputAttachments, "uint32_t maxPerStageDescriptorInputAttachments", os, indent +1);
    Print(src.maxPerStageResources, "uint32_t maxPerStageResources", os, indent +1);
    Print(src.maxDescriptorSetSamplers, "uint32_t maxDescriptorSetSamplers", os, indent +1);
    Print(src.maxDescriptorSetUniformBuffers, "uint32_t maxDescriptorSetUniformBuffers", os, indent +1);
    Print(src.maxDescriptorSetUniformBuffersDynamic, "uint32_t maxDescriptorSetUniformBuffersDynamic", os, indent +1);
    Print(src.maxDescriptorSetStorageBuffers, "uint32_t maxDescriptorSetStorageBuffers", os, indent +1);
    Print(src.maxDescriptorSetStorageBuffersDynamic, "uint32_t maxDescriptorSetStorageBuffersDynamic", os, indent +1);
    Print(src.maxDescriptorSetSampledImages, "uint32_t maxDescriptorSetSampledImages", os, indent +1);
    Print(src.maxDescriptorSetStorageImages, "uint32_t maxDescriptorSetStorageImages", os, indent +1);
    Print(src.maxDescriptorSetInputAttachments, "uint32_t maxDescriptorSetInputAttachments", os, indent +1);
    Print(src.maxVertexInputAttributes, "uint32_t maxVertexInputAttributes", os, indent +1);
    Print(src.maxVertexInputBindings, "uint32_t maxVertexInputBindings", os, indent +1);
    Print(src.maxVertexInputAttributeOffset, "uint32_t maxVertexInputAttributeOffset", os, indent +1);
    Print(src.maxVertexInputBindingStride, "uint32_t maxVertexInputBindingStride", os, indent +1);
    Print(src.maxVertexOutputComponents, "uint32_t maxVertexOutputComponents", os, indent +1);
    Print(src.maxTessellationGenerationLevel, "uint32_t maxTessellationGenerationLevel", os, indent +1);
    Print(src.maxTessellationPatchSize, "uint32_t maxTessellationPatchSize", os, indent +1);
    Print(src.maxTessellationControlPerVertexInputComponents, "uint32_t maxTessellationControlPerVertexInputComponents", os, indent +1);
    Print(src.maxTessellationControlPerVertexOutputComponents, "uint32_t maxTessellationControlPerVertexOutputComponents", os, indent +1);
    Print(src.maxTessellationControlPerPatchOutputComponents, "uint32_t maxTessellationControlPerPatchOutputComponents", os, indent +1);
    Print(src.maxTessellationControlTotalOutputComponents, "uint32_t maxTessellationControlTotalOutputComponents", os, indent +1);
    Print(src.maxTessellationEvaluationInputComponents, "uint32_t maxTessellationEvaluationInputComponents", os, indent +1);
    Print(src.maxTessellationEvaluationOutputComponents, "uint32_t maxTessellationEvaluationOutputComponents", os, indent +1);
    Print(src.maxGeometryShaderInvocations, "uint32_t maxGeometryShaderInvocations", os, indent +1);
    Print(src.maxGeometryInputComponents, "uint32_t maxGeometryInputComponents", os, indent +1);
    Print(src.maxGeometryOutputComponents, "uint32_t maxGeometryOutputComponents", os, indent +1);
    Print(src.maxGeometryOutputVertices, "uint32_t maxGeometryOutputVertices", os, indent +1);
    Print(src.maxGeometryTotalOutputComponents, "uint32_t maxGeometryTotalOutputComponents", os, indent +1);
    Print(src.maxFragmentInputComponents, "uint32_t maxFragmentInputComponents", os, indent +1);
    Print(src.maxFragmentOutputAttachments, "uint32_t maxFragmentOutputAttachments", os, indent +1);
    Print(src.maxFragmentDualSrcAttachments, "uint32_t maxFragmentDualSrcAttachments", os, indent +1);
    Print(src.maxFragmentCombinedOutputResources, "uint32_t maxFragmentCombinedOutputResources", os, indent +1);
    Print(src.maxComputeSharedMemorySize, "uint32_t maxComputeSharedMemorySize", os, indent +1);
    PrintArray(src.maxComputeWorkGroupCount, 3, "uint32_t [3] maxComputeWorkGroupCount", os, indent + 1);
    Print(src.maxComputeWorkGroupInvocations, "uint32_t maxComputeWorkGroupInvocations", os, indent +1);
    PrintArray(src.maxComputeWorkGroupSize, 3, "uint32_t [3] maxComputeWorkGroupSize", os, indent + 1);
    Print(src.subPixelPrecisionBits, "uint32_t subPixelPrecisionBits", os, indent +1);
    Print(src.subTexelPrecisionBits, "uint32_t subTexelPrecisionBits", os, indent +1);
    Print(src.mipmapPrecisionBits, "uint32_t mipmapPrecisionBits", os, indent +1);
    Print(src.maxDrawIndexedIndexValue, "uint32_t maxDrawIndexedIndexValue", os, indent +1);
    Print(src.maxDrawIndirectCount, "uint32_t maxDrawIndirectCount", os, indent +1);
    Print(src.maxSamplerLodBias, "float maxSamplerLodBias", os, indent +1);
    Print(src.maxSamplerAnisotropy, "float maxSamplerAnisotropy", os, indent +1);
    Print(src.maxViewports, "uint32_t maxViewports", os, indent +1);
    PrintArray(src.maxViewportDimensions, 2, "uint32_t [2] maxViewportDimensions", os, indent + 1);
    PrintArray(src.viewportBoundsRange, 2, "float [2] viewportBoundsRange", os, indent + 1);
    Print(src.viewportSubPixelBits, "uint32_t viewportSubPixelBits", os, indent +1);
    Print(src.minMemoryMapAlignment, "size_t minMemoryMapAlignment", os, indent +1);
    Print(src.minTexelBufferOffsetAlignment, "VkDeviceSize minTexelBufferOffsetAlignment", os, indent +1);
    Print(src.minUniformBufferOffsetAlignment, "VkDeviceSize minUniformBufferOffsetAlignment", os, indent +1);
    Print(src.minStorageBufferOffsetAlignment, "VkDeviceSize minStorageBufferOffsetAlignment", os, indent +1);
    Print(src.minTexelOffset, "int32_t minTexelOffset", os, indent +1);
    Print(src.maxTexelOffset, "uint32_t maxTexelOffset", os, indent +1);
    Print(src.minTexelGatherOffset, "int32_t minTexelGatherOffset", os, indent +1);
    Print(src.maxTexelGatherOffset, "uint32_t maxTexelGatherOffset", os, indent +1);
    Print(src.minInterpolationOffset, "float minInterpolationOffset", os, indent +1);
    Print(src.maxInterpolationOffset, "float maxInterpolationOffset", os, indent +1);
    Print(src.subPixelInterpolationOffsetBits, "uint32_t subPixelInterpolationOffsetBits", os, indent +1);
    Print(src.maxFramebufferWidth, "uint32_t maxFramebufferWidth", os, indent +1);
    Print(src.maxFramebufferHeight, "uint32_t maxFramebufferHeight", os, indent +1);
    Print(src.maxFramebufferLayers, "uint32_t maxFramebufferLayers", os, indent +1);
    Print(src.framebufferColorSampleCounts, "VkSampleCountFlags framebufferColorSampleCounts", os, indent +1);
    Print(src.framebufferDepthSampleCounts, "VkSampleCountFlags framebufferDepthSampleCounts", os, indent +1);
    Print(src.framebufferStencilSampleCounts, "VkSampleCountFlags framebufferStencilSampleCounts", os, indent +1);
    Print(src.framebufferNoAttachmentsSampleCounts, "VkSampleCountFlags framebufferNoAttachmentsSampleCounts", os, indent +1);
    Print(src.maxColorAttachments, "uint32_t maxColorAttachments", os, indent +1);
    Print(src.sampledImageColorSampleCounts, "VkSampleCountFlags sampledImageColorSampleCounts", os, indent +1);
    Print(src.sampledImageIntegerSampleCounts, "VkSampleCountFlags sampledImageIntegerSampleCounts", os, indent +1);
    Print(src.sampledImageDepthSampleCounts, "VkSampleCountFlags sampledImageDepthSampleCounts", os, indent +1);
    Print(src.sampledImageStencilSampleCounts, "VkSampleCountFlags sampledImageStencilSampleCounts", os, indent +1);
    Print(src.storageImageSampleCounts, "VkSampleCountFlags storageImageSampleCounts", os, indent +1);
    Print(src.maxSampleMaskWords, "uint32_t maxSampleMaskWords", os, indent +1);
    Print(src.timestampComputeAndGraphics, "VkBool32 timestampComputeAndGraphics", os, indent +1);
    Print(src.timestampPeriod, "float timestampPeriod", os, indent +1);
    Print(src.maxClipDistances, "uint32_t maxClipDistances", os, indent +1);
    Print(src.maxCullDistances, "uint32_t maxCullDistances", os, indent +1);
    Print(src.maxCombinedClipAndCullDistances, "uint32_t maxCombinedClipAndCullDistances", os, indent +1);
    Print(src.discreteQueuePriorities, "uint32_t discreteQueuePriorities", os, indent +1);
    PrintArray(src.pointSizeRange, 2, "float [2] pointSizeRange", os, indent + 1);
    PrintArray(src.lineWidthRange, 2, "float [2] lineWidthRange", os, indent + 1);
    Print(src.pointSizeGranularity, "float pointSizeGranularity", os, indent +1);
    Print(src.lineWidthGranularity, "float lineWidthGranularity", os, indent +1);
    Print(src.strictLines, "VkBool32 strictLines", os, indent +1);
    Print(src.standardSampleLocations, "VkBool32 standardSampleLocations", os, indent +1);
    Print(src.optimalBufferCopyOffsetAlignment, "VkDeviceSize optimalBufferCopyOffsetAlignment", os, indent +1);
    Print(src.optimalBufferCopyRowPitchAlignment, "VkDeviceSize optimalBufferCopyRowPitchAlignment", os, indent +1);
    Print(src.nonCoherentAtomSize, "VkDeviceSize nonCoherentAtomSize", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceLineRasterizationFeaturesEXT>(VkPhysicalDeviceLineRasterizationFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.rectangularLines, "VkBool32 rectangularLines", os, indent +1);
    Print(src.bresenhamLines, "VkBool32 bresenhamLines", os, indent +1);
    Print(src.smoothLines, "VkBool32 smoothLines", os, indent +1);
    Print(src.stippledRectangularLines, "VkBool32 stippledRectangularLines", os, indent +1);
    Print(src.stippledBresenhamLines, "VkBool32 stippledBresenhamLines", os, indent +1);
    Print(src.stippledSmoothLines, "VkBool32 stippledSmoothLines", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceLineRasterizationPropertiesEXT>(VkPhysicalDeviceLineRasterizationPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.lineSubPixelPrecisionBits, "uint32_t lineSubPixelPrecisionBits", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceLinearColorAttachmentFeaturesNV>(VkPhysicalDeviceLinearColorAttachmentFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.linearColorAttachment, "VkBool32 linearColorAttachment", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceMaintenance3Properties>(VkPhysicalDeviceMaintenance3Properties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.maxPerSetDescriptors, "uint32_t maxPerSetDescriptors", os, indent +1);
    Print(src.maxMemoryAllocationSize, "VkDeviceSize maxMemoryAllocationSize", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceMaintenance4Features>(VkPhysicalDeviceMaintenance4Features const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.maintenance4, "VkBool32 maintenance4", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceMaintenance4Properties>(VkPhysicalDeviceMaintenance4Properties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.maxBufferSize, "VkDeviceSize maxBufferSize", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceMemoryBudgetPropertiesEXT>(VkPhysicalDeviceMemoryBudgetPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    PrintArray(src.heapBudget, 16, "VkDeviceSize [16] heapBudget", os, indent + 1);
    PrintArray(src.heapUsage, 16, "VkDeviceSize [16] heapUsage", os, indent + 1);
}

template <>
inline void Print<VkPhysicalDeviceMemoryDecompressionFeaturesNV>(VkPhysicalDeviceMemoryDecompressionFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.memoryDecompression, "VkBool32 memoryDecompression", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceMemoryDecompressionPropertiesNV>(VkPhysicalDeviceMemoryDecompressionPropertiesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.decompressionMethods, "VkMemoryDecompressionMethodFlagsNV decompressionMethods", os, indent +1);
    Print(src.maxDecompressionIndirectCount, "uint64_t maxDecompressionIndirectCount", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceMemoryPriorityFeaturesEXT>(VkPhysicalDeviceMemoryPriorityFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.memoryPriority, "VkBool32 memoryPriority", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceMemoryProperties>(VkPhysicalDeviceMemoryProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.memoryTypeCount, "uint32_t memoryTypeCount", os, indent +1);
    PrintArray(src.memoryTypes, 32, "VkMemoryType [32] memoryTypes", os, indent + 1);
    Print(src.memoryHeapCount, "uint32_t memoryHeapCount", os, indent +1);
    PrintArray(src.memoryHeaps, 16, "VkMemoryHeap [16] memoryHeaps", os, indent + 1);
}

template <>
inline void Print<VkPhysicalDeviceMemoryProperties2>(VkPhysicalDeviceMemoryProperties2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.memoryProperties, "VkPhysicalDeviceMemoryProperties memoryProperties", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceMeshShaderFeaturesEXT>(VkPhysicalDeviceMeshShaderFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.taskShader, "VkBool32 taskShader", os, indent +1);
    Print(src.meshShader, "VkBool32 meshShader", os, indent +1);
    Print(src.multiviewMeshShader, "VkBool32 multiviewMeshShader", os, indent +1);
    Print(src.primitiveFragmentShadingRateMeshShader, "VkBool32 primitiveFragmentShadingRateMeshShader", os, indent +1);
    Print(src.meshShaderQueries, "VkBool32 meshShaderQueries", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceMeshShaderFeaturesNV>(VkPhysicalDeviceMeshShaderFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.taskShader, "VkBool32 taskShader", os, indent +1);
    Print(src.meshShader, "VkBool32 meshShader", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceMeshShaderPropertiesEXT>(VkPhysicalDeviceMeshShaderPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.maxTaskWorkGroupTotalCount, "uint32_t maxTaskWorkGroupTotalCount", os, indent +1);
    PrintArray(src.maxTaskWorkGroupCount, 3, "uint32_t [3] maxTaskWorkGroupCount", os, indent + 1);
    Print(src.maxTaskWorkGroupInvocations, "uint32_t maxTaskWorkGroupInvocations", os, indent +1);
    PrintArray(src.maxTaskWorkGroupSize, 3, "uint32_t [3] maxTaskWorkGroupSize", os, indent + 1);
    Print(src.maxTaskPayloadSize, "uint32_t maxTaskPayloadSize", os, indent +1);
    Print(src.maxTaskSharedMemorySize, "uint32_t maxTaskSharedMemorySize", os, indent +1);
    Print(src.maxTaskPayloadAndSharedMemorySize, "uint32_t maxTaskPayloadAndSharedMemorySize", os, indent +1);
    Print(src.maxMeshWorkGroupTotalCount, "uint32_t maxMeshWorkGroupTotalCount", os, indent +1);
    PrintArray(src.maxMeshWorkGroupCount, 3, "uint32_t [3] maxMeshWorkGroupCount", os, indent + 1);
    Print(src.maxMeshWorkGroupInvocations, "uint32_t maxMeshWorkGroupInvocations", os, indent +1);
    PrintArray(src.maxMeshWorkGroupSize, 3, "uint32_t [3] maxMeshWorkGroupSize", os, indent + 1);
    Print(src.maxMeshSharedMemorySize, "uint32_t maxMeshSharedMemorySize", os, indent +1);
    Print(src.maxMeshPayloadAndSharedMemorySize, "uint32_t maxMeshPayloadAndSharedMemorySize", os, indent +1);
    Print(src.maxMeshOutputMemorySize, "uint32_t maxMeshOutputMemorySize", os, indent +1);
    Print(src.maxMeshPayloadAndOutputMemorySize, "uint32_t maxMeshPayloadAndOutputMemorySize", os, indent +1);
    Print(src.maxMeshOutputComponents, "uint32_t maxMeshOutputComponents", os, indent +1);
    Print(src.maxMeshOutputVertices, "uint32_t maxMeshOutputVertices", os, indent +1);
    Print(src.maxMeshOutputPrimitives, "uint32_t maxMeshOutputPrimitives", os, indent +1);
    Print(src.maxMeshOutputLayers, "uint32_t maxMeshOutputLayers", os, indent +1);
    Print(src.maxMeshMultiviewViewCount, "uint32_t maxMeshMultiviewViewCount", os, indent +1);
    Print(src.meshOutputPerVertexGranularity, "uint32_t meshOutputPerVertexGranularity", os, indent +1);
    Print(src.meshOutputPerPrimitiveGranularity, "uint32_t meshOutputPerPrimitiveGranularity", os, indent +1);
    Print(src.maxPreferredTaskWorkGroupInvocations, "uint32_t maxPreferredTaskWorkGroupInvocations", os, indent +1);
    Print(src.maxPreferredMeshWorkGroupInvocations, "uint32_t maxPreferredMeshWorkGroupInvocations", os, indent +1);
    Print(src.prefersLocalInvocationVertexOutput, "VkBool32 prefersLocalInvocationVertexOutput", os, indent +1);
    Print(src.prefersLocalInvocationPrimitiveOutput, "VkBool32 prefersLocalInvocationPrimitiveOutput", os, indent +1);
    Print(src.prefersCompactVertexOutput, "VkBool32 prefersCompactVertexOutput", os, indent +1);
    Print(src.prefersCompactPrimitiveOutput, "VkBool32 prefersCompactPrimitiveOutput", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceMeshShaderPropertiesNV>(VkPhysicalDeviceMeshShaderPropertiesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.maxDrawMeshTasksCount, "uint32_t maxDrawMeshTasksCount", os, indent +1);
    Print(src.maxTaskWorkGroupInvocations, "uint32_t maxTaskWorkGroupInvocations", os, indent +1);
    PrintArray(src.maxTaskWorkGroupSize, 3, "uint32_t [3] maxTaskWorkGroupSize", os, indent + 1);
    Print(src.maxTaskTotalMemorySize, "uint32_t maxTaskTotalMemorySize", os, indent +1);
    Print(src.maxTaskOutputCount, "uint32_t maxTaskOutputCount", os, indent +1);
    Print(src.maxMeshWorkGroupInvocations, "uint32_t maxMeshWorkGroupInvocations", os, indent +1);
    PrintArray(src.maxMeshWorkGroupSize, 3, "uint32_t [3] maxMeshWorkGroupSize", os, indent + 1);
    Print(src.maxMeshTotalMemorySize, "uint32_t maxMeshTotalMemorySize", os, indent +1);
    Print(src.maxMeshOutputVertices, "uint32_t maxMeshOutputVertices", os, indent +1);
    Print(src.maxMeshOutputPrimitives, "uint32_t maxMeshOutputPrimitives", os, indent +1);
    Print(src.maxMeshMultiviewViewCount, "uint32_t maxMeshMultiviewViewCount", os, indent +1);
    Print(src.meshOutputPerVertexGranularity, "uint32_t meshOutputPerVertexGranularity", os, indent +1);
    Print(src.meshOutputPerPrimitiveGranularity, "uint32_t meshOutputPerPrimitiveGranularity", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceMultiDrawFeaturesEXT>(VkPhysicalDeviceMultiDrawFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.multiDraw, "VkBool32 multiDraw", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceMultiDrawPropertiesEXT>(VkPhysicalDeviceMultiDrawPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.maxMultiDrawCount, "uint32_t maxMultiDrawCount", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT>(VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.multisampledRenderToSingleSampled, "VkBool32 multisampledRenderToSingleSampled", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceMultiviewFeatures>(VkPhysicalDeviceMultiviewFeatures const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.multiview, "VkBool32 multiview", os, indent +1);
    Print(src.multiviewGeometryShader, "VkBool32 multiviewGeometryShader", os, indent +1);
    Print(src.multiviewTessellationShader, "VkBool32 multiviewTessellationShader", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>(VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.perViewPositionAllComponents, "VkBool32 perViewPositionAllComponents", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM>(VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.multiviewPerViewViewports, "VkBool32 multiviewPerViewViewports", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceMultiviewProperties>(VkPhysicalDeviceMultiviewProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.maxMultiviewViewCount, "uint32_t maxMultiviewViewCount", os, indent +1);
    Print(src.maxMultiviewInstanceIndex, "uint32_t maxMultiviewInstanceIndex", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT>(VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.mutableDescriptorType, "VkBool32 mutableDescriptorType", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT>(VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.nonSeamlessCubeMap, "VkBool32 nonSeamlessCubeMap", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceOpacityMicromapFeaturesEXT>(VkPhysicalDeviceOpacityMicromapFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.micromap, "VkBool32 micromap", os, indent +1);
    Print(src.micromapCaptureReplay, "VkBool32 micromapCaptureReplay", os, indent +1);
    Print(src.micromapHostCommands, "VkBool32 micromapHostCommands", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceOpacityMicromapPropertiesEXT>(VkPhysicalDeviceOpacityMicromapPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.maxOpacity2StateSubdivisionLevel, "uint32_t maxOpacity2StateSubdivisionLevel", os, indent +1);
    Print(src.maxOpacity4StateSubdivisionLevel, "uint32_t maxOpacity4StateSubdivisionLevel", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceOpticalFlowFeaturesNV>(VkPhysicalDeviceOpticalFlowFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.opticalFlow, "VkBool32 opticalFlow", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceOpticalFlowPropertiesNV>(VkPhysicalDeviceOpticalFlowPropertiesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.supportedOutputGridSizes, "VkOpticalFlowGridSizeFlagsNV supportedOutputGridSizes", os, indent +1);
    Print(src.supportedHintGridSizes, "VkOpticalFlowGridSizeFlagsNV supportedHintGridSizes", os, indent +1);
    Print(src.hintSupported, "VkBool32 hintSupported", os, indent +1);
    Print(src.costSupported, "VkBool32 costSupported", os, indent +1);
    Print(src.bidirectionalFlowSupported, "VkBool32 bidirectionalFlowSupported", os, indent +1);
    Print(src.globalFlowSupported, "VkBool32 globalFlowSupported", os, indent +1);
    Print(src.minWidth, "uint32_t minWidth", os, indent +1);
    Print(src.minHeight, "uint32_t minHeight", os, indent +1);
    Print(src.maxWidth, "uint32_t maxWidth", os, indent +1);
    Print(src.maxHeight, "uint32_t maxHeight", os, indent +1);
    Print(src.maxNumRegionsOfInterest, "uint32_t maxNumRegionsOfInterest", os, indent +1);
}

template <>
inline void Print<VkPhysicalDevicePCIBusInfoPropertiesEXT>(VkPhysicalDevicePCIBusInfoPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.pciDomain, "uint32_t pciDomain", os, indent +1);
    Print(src.pciBus, "uint32_t pciBus", os, indent +1);
    Print(src.pciDevice, "uint32_t pciDevice", os, indent +1);
    Print(src.pciFunction, "uint32_t pciFunction", os, indent +1);
}

template <>
inline void Print<VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT>(VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.pageableDeviceLocalMemory, "VkBool32 pageableDeviceLocalMemory", os, indent +1);
}

template <>
inline void Print<VkPhysicalDevicePerformanceQueryFeaturesKHR>(VkPhysicalDevicePerformanceQueryFeaturesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.performanceCounterQueryPools, "VkBool32 performanceCounterQueryPools", os, indent +1);
    Print(src.performanceCounterMultipleQueryPools, "VkBool32 performanceCounterMultipleQueryPools", os, indent +1);
}

template <>
inline void Print<VkPhysicalDevicePerformanceQueryPropertiesKHR>(VkPhysicalDevicePerformanceQueryPropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.allowCommandBufferQueryCopies, "VkBool32 allowCommandBufferQueryCopies", os, indent +1);
}

template <>
inline void Print<VkPhysicalDevicePipelineCreationCacheControlFeatures>(VkPhysicalDevicePipelineCreationCacheControlFeatures const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.pipelineCreationCacheControl, "VkBool32 pipelineCreationCacheControl", os, indent +1);
}

template <>
inline void Print<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR>(VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.pipelineExecutableInfo, "VkBool32 pipelineExecutableInfo", os, indent +1);
}

template <>
inline void Print<VkPhysicalDevicePipelinePropertiesFeaturesEXT>(VkPhysicalDevicePipelinePropertiesFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.pipelinePropertiesIdentifier, "VkBool32 pipelinePropertiesIdentifier", os, indent +1);
}

template <>
inline void Print<VkPhysicalDevicePipelineProtectedAccessFeaturesEXT>(VkPhysicalDevicePipelineProtectedAccessFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.pipelineProtectedAccess, "VkBool32 pipelineProtectedAccess", os, indent +1);
}

template <>
inline void Print<VkPhysicalDevicePipelineRobustnessFeaturesEXT>(VkPhysicalDevicePipelineRobustnessFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.pipelineRobustness, "VkBool32 pipelineRobustness", os, indent +1);
}

template <>
inline void Print<VkPhysicalDevicePipelineRobustnessPropertiesEXT>(VkPhysicalDevicePipelineRobustnessPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.defaultRobustnessStorageBuffers, "VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessStorageBuffers", os, indent +1);
    Print(src.defaultRobustnessUniformBuffers, "VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessUniformBuffers", os, indent +1);
    Print(src.defaultRobustnessVertexInputs, "VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessVertexInputs", os, indent +1);
    Print(src.defaultRobustnessImages, "VkPipelineRobustnessImageBehaviorEXT defaultRobustnessImages", os, indent +1);
}

template <>
inline void Print<VkPhysicalDevicePointClippingProperties>(VkPhysicalDevicePointClippingProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.pointClippingBehavior, "VkPointClippingBehavior pointClippingBehavior", os, indent +1);
}

template <>
inline void Print<VkPhysicalDevicePortabilitySubsetFeaturesKHR>(VkPhysicalDevicePortabilitySubsetFeaturesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.constantAlphaColorBlendFactors, "VkBool32 constantAlphaColorBlendFactors", os, indent +1);
    Print(src.events, "VkBool32 events", os, indent +1);
    Print(src.imageViewFormatReinterpretation, "VkBool32 imageViewFormatReinterpretation", os, indent +1);
    Print(src.imageViewFormatSwizzle, "VkBool32 imageViewFormatSwizzle", os, indent +1);
    Print(src.imageView2DOn3DImage, "VkBool32 imageView2DOn3DImage", os, indent +1);
    Print(src.multisampleArrayImage, "VkBool32 multisampleArrayImage", os, indent +1);
    Print(src.mutableComparisonSamplers, "VkBool32 mutableComparisonSamplers", os, indent +1);
    Print(src.pointPolygons, "VkBool32 pointPolygons", os, indent +1);
    Print(src.samplerMipLodBias, "VkBool32 samplerMipLodBias", os, indent +1);
    Print(src.separateStencilMaskRef, "VkBool32 separateStencilMaskRef", os, indent +1);
    Print(src.shaderSampleRateInterpolationFunctions, "VkBool32 shaderSampleRateInterpolationFunctions", os, indent +1);
    Print(src.tessellationIsolines, "VkBool32 tessellationIsolines", os, indent +1);
    Print(src.tessellationPointMode, "VkBool32 tessellationPointMode", os, indent +1);
    Print(src.triangleFans, "VkBool32 triangleFans", os, indent +1);
    Print(src.vertexAttributeAccessBeyondStride, "VkBool32 vertexAttributeAccessBeyondStride", os, indent +1);
}

template <>
inline void Print<VkPhysicalDevicePortabilitySubsetPropertiesKHR>(VkPhysicalDevicePortabilitySubsetPropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.minVertexInputBindingStrideAlignment, "uint32_t minVertexInputBindingStrideAlignment", os, indent +1);
}

template <>
inline void Print<VkPhysicalDevicePresentBarrierFeaturesNV>(VkPhysicalDevicePresentBarrierFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.presentBarrier, "VkBool32 presentBarrier", os, indent +1);
}

template <>
inline void Print<VkPhysicalDevicePresentIdFeaturesKHR>(VkPhysicalDevicePresentIdFeaturesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.presentId, "VkBool32 presentId", os, indent +1);
}

template <>
inline void Print<VkPhysicalDevicePresentWaitFeaturesKHR>(VkPhysicalDevicePresentWaitFeaturesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.presentWait, "VkBool32 presentWait", os, indent +1);
}

template <>
inline void Print<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT>(VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.primitiveTopologyListRestart, "VkBool32 primitiveTopologyListRestart", os, indent +1);
    Print(src.primitiveTopologyPatchListRestart, "VkBool32 primitiveTopologyPatchListRestart", os, indent +1);
}

template <>
inline void Print<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT>(VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.primitivesGeneratedQuery, "VkBool32 primitivesGeneratedQuery", os, indent +1);
    Print(src.primitivesGeneratedQueryWithRasterizerDiscard, "VkBool32 primitivesGeneratedQueryWithRasterizerDiscard", os, indent +1);
    Print(src.primitivesGeneratedQueryWithNonZeroStreams, "VkBool32 primitivesGeneratedQueryWithNonZeroStreams", os, indent +1);
}

template <>
inline void Print<VkPhysicalDevicePrivateDataFeatures>(VkPhysicalDevicePrivateDataFeatures const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.privateData, "VkBool32 privateData", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceProperties>(VkPhysicalDeviceProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.apiVersion, "uint32_t apiVersion", os, indent +1);
    Print(src.driverVersion, "uint32_t driverVersion", os, indent +1);
    Print(src.vendorID, "uint32_t vendorID", os, indent +1);
    Print(src.deviceID, "uint32_t deviceID", os, indent +1);
    Print(src.deviceType, "VkPhysicalDeviceType deviceType", os, indent +1);
    PrintArray(src.deviceName, 256, "char [256] deviceName", os, indent + 1);
    PrintArray(src.pipelineCacheUUID, 16, "uint8_t [16] pipelineCacheUUID", os, indent + 1);
    Print(src.limits, "VkPhysicalDeviceLimits limits", os, indent +1);
    Print(src.sparseProperties, "VkPhysicalDeviceSparseProperties sparseProperties", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceProperties2>(VkPhysicalDeviceProperties2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.properties, "VkPhysicalDeviceProperties properties", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceProtectedMemoryFeatures>(VkPhysicalDeviceProtectedMemoryFeatures const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.protectedMemory, "VkBool32 protectedMemory", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceProtectedMemoryProperties>(VkPhysicalDeviceProtectedMemoryProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.protectedNoFault, "VkBool32 protectedNoFault", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceProvokingVertexFeaturesEXT>(VkPhysicalDeviceProvokingVertexFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.provokingVertexLast, "VkBool32 provokingVertexLast", os, indent +1);
    Print(src.transformFeedbackPreservesProvokingVertex, "VkBool32 transformFeedbackPreservesProvokingVertex", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceProvokingVertexPropertiesEXT>(VkPhysicalDeviceProvokingVertexPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.provokingVertexModePerPipeline, "VkBool32 provokingVertexModePerPipeline", os, indent +1);
    Print(src.transformFeedbackPreservesTriangleFanProvokingVertex, "VkBool32 transformFeedbackPreservesTriangleFanProvokingVertex", os, indent +1);
}

template <>
inline void Print<VkPhysicalDevicePushDescriptorPropertiesKHR>(VkPhysicalDevicePushDescriptorPropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.maxPushDescriptors, "uint32_t maxPushDescriptors", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT>(VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.formatRgba10x6WithoutYCbCrSampler, "VkBool32 formatRgba10x6WithoutYCbCrSampler", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT>(VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.rasterizationOrderColorAttachmentAccess, "VkBool32 rasterizationOrderColorAttachmentAccess", os, indent +1);
    Print(src.rasterizationOrderDepthAttachmentAccess, "VkBool32 rasterizationOrderDepthAttachmentAccess", os, indent +1);
    Print(src.rasterizationOrderStencilAttachmentAccess, "VkBool32 rasterizationOrderStencilAttachmentAccess", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceRayQueryFeaturesKHR>(VkPhysicalDeviceRayQueryFeaturesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.rayQuery, "VkBool32 rayQuery", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV>(VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.rayTracingInvocationReorder, "VkBool32 rayTracingInvocationReorder", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV>(VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.rayTracingInvocationReorderReorderingHint, "VkRayTracingInvocationReorderModeNV rayTracingInvocationReorderReorderingHint", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR>(VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.rayTracingMaintenance1, "VkBool32 rayTracingMaintenance1", os, indent +1);
    Print(src.rayTracingPipelineTraceRaysIndirect2, "VkBool32 rayTracingPipelineTraceRaysIndirect2", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV>(VkPhysicalDeviceRayTracingMotionBlurFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.rayTracingMotionBlur, "VkBool32 rayTracingMotionBlur", os, indent +1);
    Print(src.rayTracingMotionBlurPipelineTraceRaysIndirect, "VkBool32 rayTracingMotionBlurPipelineTraceRaysIndirect", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceRayTracingPipelineFeaturesKHR>(VkPhysicalDeviceRayTracingPipelineFeaturesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.rayTracingPipeline, "VkBool32 rayTracingPipeline", os, indent +1);
    Print(src.rayTracingPipelineShaderGroupHandleCaptureReplay, "VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplay", os, indent +1);
    Print(src.rayTracingPipelineShaderGroupHandleCaptureReplayMixed, "VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed", os, indent +1);
    Print(src.rayTracingPipelineTraceRaysIndirect, "VkBool32 rayTracingPipelineTraceRaysIndirect", os, indent +1);
    Print(src.rayTraversalPrimitiveCulling, "VkBool32 rayTraversalPrimitiveCulling", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceRayTracingPipelinePropertiesKHR>(VkPhysicalDeviceRayTracingPipelinePropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.shaderGroupHandleSize, "uint32_t shaderGroupHandleSize", os, indent +1);
    Print(src.maxRayRecursionDepth, "uint32_t maxRayRecursionDepth", os, indent +1);
    Print(src.maxShaderGroupStride, "uint32_t maxShaderGroupStride", os, indent +1);
    Print(src.shaderGroupBaseAlignment, "uint32_t shaderGroupBaseAlignment", os, indent +1);
    Print(src.shaderGroupHandleCaptureReplaySize, "uint32_t shaderGroupHandleCaptureReplaySize", os, indent +1);
    Print(src.maxRayDispatchInvocationCount, "uint32_t maxRayDispatchInvocationCount", os, indent +1);
    Print(src.shaderGroupHandleAlignment, "uint32_t shaderGroupHandleAlignment", os, indent +1);
    Print(src.maxRayHitAttributeSize, "uint32_t maxRayHitAttributeSize", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceRayTracingPropertiesNV>(VkPhysicalDeviceRayTracingPropertiesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.shaderGroupHandleSize, "uint32_t shaderGroupHandleSize", os, indent +1);
    Print(src.maxRecursionDepth, "uint32_t maxRecursionDepth", os, indent +1);
    Print(src.maxShaderGroupStride, "uint32_t maxShaderGroupStride", os, indent +1);
    Print(src.shaderGroupBaseAlignment, "uint32_t shaderGroupBaseAlignment", os, indent +1);
    Print(src.maxGeometryCount, "uint64_t maxGeometryCount", os, indent +1);
    Print(src.maxInstanceCount, "uint64_t maxInstanceCount", os, indent +1);
    Print(src.maxTriangleCount, "uint64_t maxTriangleCount", os, indent +1);
    Print(src.maxDescriptorSetAccelerationStructures, "uint32_t maxDescriptorSetAccelerationStructures", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV>(VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.representativeFragmentTest, "VkBool32 representativeFragmentTest", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceRobustness2FeaturesEXT>(VkPhysicalDeviceRobustness2FeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.robustBufferAccess2, "VkBool32 robustBufferAccess2", os, indent +1);
    Print(src.robustImageAccess2, "VkBool32 robustImageAccess2", os, indent +1);
    Print(src.nullDescriptor, "VkBool32 nullDescriptor", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceRobustness2PropertiesEXT>(VkPhysicalDeviceRobustness2PropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.robustStorageBufferAccessSizeAlignment, "VkDeviceSize robustStorageBufferAccessSizeAlignment", os, indent +1);
    Print(src.robustUniformBufferAccessSizeAlignment, "VkDeviceSize robustUniformBufferAccessSizeAlignment", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceSampleLocationsPropertiesEXT>(VkPhysicalDeviceSampleLocationsPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.sampleLocationSampleCounts, "VkSampleCountFlags sampleLocationSampleCounts", os, indent +1);
    Print(src.maxSampleLocationGridSize, "VkExtent2D maxSampleLocationGridSize", os, indent +1);
    PrintArray(src.sampleLocationCoordinateRange, 2, "float [2] sampleLocationCoordinateRange", os, indent + 1);
    Print(src.sampleLocationSubPixelBits, "uint32_t sampleLocationSubPixelBits", os, indent +1);
    Print(src.variableSampleLocations, "VkBool32 variableSampleLocations", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceSamplerFilterMinmaxProperties>(VkPhysicalDeviceSamplerFilterMinmaxProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.filterMinmaxSingleComponentFormats, "VkBool32 filterMinmaxSingleComponentFormats", os, indent +1);
    Print(src.filterMinmaxImageComponentMapping, "VkBool32 filterMinmaxImageComponentMapping", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceSamplerYcbcrConversionFeatures>(VkPhysicalDeviceSamplerYcbcrConversionFeatures const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.samplerYcbcrConversion, "VkBool32 samplerYcbcrConversion", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceScalarBlockLayoutFeatures>(VkPhysicalDeviceScalarBlockLayoutFeatures const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.scalarBlockLayout, "VkBool32 scalarBlockLayout", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures>(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.separateDepthStencilLayouts, "VkBool32 separateDepthStencilLayouts", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT>(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.shaderBufferFloat16Atomics, "VkBool32 shaderBufferFloat16Atomics", os, indent +1);
    Print(src.shaderBufferFloat16AtomicAdd, "VkBool32 shaderBufferFloat16AtomicAdd", os, indent +1);
    Print(src.shaderBufferFloat16AtomicMinMax, "VkBool32 shaderBufferFloat16AtomicMinMax", os, indent +1);
    Print(src.shaderBufferFloat32AtomicMinMax, "VkBool32 shaderBufferFloat32AtomicMinMax", os, indent +1);
    Print(src.shaderBufferFloat64AtomicMinMax, "VkBool32 shaderBufferFloat64AtomicMinMax", os, indent +1);
    Print(src.shaderSharedFloat16Atomics, "VkBool32 shaderSharedFloat16Atomics", os, indent +1);
    Print(src.shaderSharedFloat16AtomicAdd, "VkBool32 shaderSharedFloat16AtomicAdd", os, indent +1);
    Print(src.shaderSharedFloat16AtomicMinMax, "VkBool32 shaderSharedFloat16AtomicMinMax", os, indent +1);
    Print(src.shaderSharedFloat32AtomicMinMax, "VkBool32 shaderSharedFloat32AtomicMinMax", os, indent +1);
    Print(src.shaderSharedFloat64AtomicMinMax, "VkBool32 shaderSharedFloat64AtomicMinMax", os, indent +1);
    Print(src.shaderImageFloat32AtomicMinMax, "VkBool32 shaderImageFloat32AtomicMinMax", os, indent +1);
    Print(src.sparseImageFloat32AtomicMinMax, "VkBool32 sparseImageFloat32AtomicMinMax", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT>(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.shaderBufferFloat32Atomics, "VkBool32 shaderBufferFloat32Atomics", os, indent +1);
    Print(src.shaderBufferFloat32AtomicAdd, "VkBool32 shaderBufferFloat32AtomicAdd", os, indent +1);
    Print(src.shaderBufferFloat64Atomics, "VkBool32 shaderBufferFloat64Atomics", os, indent +1);
    Print(src.shaderBufferFloat64AtomicAdd, "VkBool32 shaderBufferFloat64AtomicAdd", os, indent +1);
    Print(src.shaderSharedFloat32Atomics, "VkBool32 shaderSharedFloat32Atomics", os, indent +1);
    Print(src.shaderSharedFloat32AtomicAdd, "VkBool32 shaderSharedFloat32AtomicAdd", os, indent +1);
    Print(src.shaderSharedFloat64Atomics, "VkBool32 shaderSharedFloat64Atomics", os, indent +1);
    Print(src.shaderSharedFloat64AtomicAdd, "VkBool32 shaderSharedFloat64AtomicAdd", os, indent +1);
    Print(src.shaderImageFloat32Atomics, "VkBool32 shaderImageFloat32Atomics", os, indent +1);
    Print(src.shaderImageFloat32AtomicAdd, "VkBool32 shaderImageFloat32AtomicAdd", os, indent +1);
    Print(src.sparseImageFloat32Atomics, "VkBool32 sparseImageFloat32Atomics", os, indent +1);
    Print(src.sparseImageFloat32AtomicAdd, "VkBool32 sparseImageFloat32AtomicAdd", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceShaderAtomicInt64Features>(VkPhysicalDeviceShaderAtomicInt64Features const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.shaderBufferInt64Atomics, "VkBool32 shaderBufferInt64Atomics", os, indent +1);
    Print(src.shaderSharedInt64Atomics, "VkBool32 shaderSharedInt64Atomics", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceShaderClockFeaturesKHR>(VkPhysicalDeviceShaderClockFeaturesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.shaderSubgroupClock, "VkBool32 shaderSubgroupClock", os, indent +1);
    Print(src.shaderDeviceClock, "VkBool32 shaderDeviceClock", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM>(VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.shaderCoreBuiltins, "VkBool32 shaderCoreBuiltins", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM>(VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.shaderCoreMask, "uint64_t shaderCoreMask", os, indent +1);
    Print(src.shaderCoreCount, "uint32_t shaderCoreCount", os, indent +1);
    Print(src.shaderWarpsPerCore, "uint32_t shaderWarpsPerCore", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceShaderCoreProperties2AMD>(VkPhysicalDeviceShaderCoreProperties2AMD const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.shaderCoreFeatures, "VkShaderCorePropertiesFlagsAMD shaderCoreFeatures", os, indent +1);
    Print(src.activeComputeUnitCount, "uint32_t activeComputeUnitCount", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceShaderCorePropertiesAMD>(VkPhysicalDeviceShaderCorePropertiesAMD const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.shaderEngineCount, "uint32_t shaderEngineCount", os, indent +1);
    Print(src.shaderArraysPerEngineCount, "uint32_t shaderArraysPerEngineCount", os, indent +1);
    Print(src.computeUnitsPerShaderArray, "uint32_t computeUnitsPerShaderArray", os, indent +1);
    Print(src.simdPerComputeUnit, "uint32_t simdPerComputeUnit", os, indent +1);
    Print(src.wavefrontsPerSimd, "uint32_t wavefrontsPerSimd", os, indent +1);
    Print(src.wavefrontSize, "uint32_t wavefrontSize", os, indent +1);
    Print(src.sgprsPerSimd, "uint32_t sgprsPerSimd", os, indent +1);
    Print(src.minSgprAllocation, "uint32_t minSgprAllocation", os, indent +1);
    Print(src.maxSgprAllocation, "uint32_t maxSgprAllocation", os, indent +1);
    Print(src.sgprAllocationGranularity, "uint32_t sgprAllocationGranularity", os, indent +1);
    Print(src.vgprsPerSimd, "uint32_t vgprsPerSimd", os, indent +1);
    Print(src.minVgprAllocation, "uint32_t minVgprAllocation", os, indent +1);
    Print(src.maxVgprAllocation, "uint32_t maxVgprAllocation", os, indent +1);
    Print(src.vgprAllocationGranularity, "uint32_t vgprAllocationGranularity", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures>(VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.shaderDemoteToHelperInvocation, "VkBool32 shaderDemoteToHelperInvocation", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceShaderDrawParametersFeatures>(VkPhysicalDeviceShaderDrawParametersFeatures const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.shaderDrawParameters, "VkBool32 shaderDrawParameters", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD>(VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.shaderEarlyAndLateFragmentTests, "VkBool32 shaderEarlyAndLateFragmentTests", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceShaderFloat16Int8Features>(VkPhysicalDeviceShaderFloat16Int8Features const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.shaderFloat16, "VkBool32 shaderFloat16", os, indent +1);
    Print(src.shaderInt8, "VkBool32 shaderInt8", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT>(VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.shaderImageInt64Atomics, "VkBool32 shaderImageInt64Atomics", os, indent +1);
    Print(src.sparseImageInt64Atomics, "VkBool32 sparseImageInt64Atomics", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceShaderImageFootprintFeaturesNV>(VkPhysicalDeviceShaderImageFootprintFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.imageFootprint, "VkBool32 imageFootprint", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceShaderIntegerDotProductFeatures>(VkPhysicalDeviceShaderIntegerDotProductFeatures const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.shaderIntegerDotProduct, "VkBool32 shaderIntegerDotProduct", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceShaderIntegerDotProductProperties>(VkPhysicalDeviceShaderIntegerDotProductProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.integerDotProduct8BitUnsignedAccelerated, "VkBool32 integerDotProduct8BitUnsignedAccelerated", os, indent +1);
    Print(src.integerDotProduct8BitSignedAccelerated, "VkBool32 integerDotProduct8BitSignedAccelerated", os, indent +1);
    Print(src.integerDotProduct8BitMixedSignednessAccelerated, "VkBool32 integerDotProduct8BitMixedSignednessAccelerated", os, indent +1);
    Print(src.integerDotProduct4x8BitPackedUnsignedAccelerated, "VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated", os, indent +1);
    Print(src.integerDotProduct4x8BitPackedSignedAccelerated, "VkBool32 integerDotProduct4x8BitPackedSignedAccelerated", os, indent +1);
    Print(src.integerDotProduct4x8BitPackedMixedSignednessAccelerated, "VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated", os, indent +1);
    Print(src.integerDotProduct16BitUnsignedAccelerated, "VkBool32 integerDotProduct16BitUnsignedAccelerated", os, indent +1);
    Print(src.integerDotProduct16BitSignedAccelerated, "VkBool32 integerDotProduct16BitSignedAccelerated", os, indent +1);
    Print(src.integerDotProduct16BitMixedSignednessAccelerated, "VkBool32 integerDotProduct16BitMixedSignednessAccelerated", os, indent +1);
    Print(src.integerDotProduct32BitUnsignedAccelerated, "VkBool32 integerDotProduct32BitUnsignedAccelerated", os, indent +1);
    Print(src.integerDotProduct32BitSignedAccelerated, "VkBool32 integerDotProduct32BitSignedAccelerated", os, indent +1);
    Print(src.integerDotProduct32BitMixedSignednessAccelerated, "VkBool32 integerDotProduct32BitMixedSignednessAccelerated", os, indent +1);
    Print(src.integerDotProduct64BitUnsignedAccelerated, "VkBool32 integerDotProduct64BitUnsignedAccelerated", os, indent +1);
    Print(src.integerDotProduct64BitSignedAccelerated, "VkBool32 integerDotProduct64BitSignedAccelerated", os, indent +1);
    Print(src.integerDotProduct64BitMixedSignednessAccelerated, "VkBool32 integerDotProduct64BitMixedSignednessAccelerated", os, indent +1);
    Print(src.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated, "VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated", os, indent +1);
    Print(src.integerDotProductAccumulatingSaturating8BitSignedAccelerated, "VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated", os, indent +1);
    Print(src.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated, "VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated", os, indent +1);
    Print(src.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated, "VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated", os, indent +1);
    Print(src.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated, "VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated", os, indent +1);
    Print(src.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated, "VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated", os, indent +1);
    Print(src.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated, "VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated", os, indent +1);
    Print(src.integerDotProductAccumulatingSaturating16BitSignedAccelerated, "VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated", os, indent +1);
    Print(src.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated, "VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated", os, indent +1);
    Print(src.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated, "VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated", os, indent +1);
    Print(src.integerDotProductAccumulatingSaturating32BitSignedAccelerated, "VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated", os, indent +1);
    Print(src.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated, "VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated", os, indent +1);
    Print(src.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated, "VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated", os, indent +1);
    Print(src.integerDotProductAccumulatingSaturating64BitSignedAccelerated, "VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated", os, indent +1);
    Print(src.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated, "VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>(VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.shaderIntegerFunctions2, "VkBool32 shaderIntegerFunctions2", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT>(VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.shaderModuleIdentifier, "VkBool32 shaderModuleIdentifier", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT>(VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    PrintArray(src.shaderModuleIdentifierAlgorithmUUID, 16, "uint8_t [16] shaderModuleIdentifierAlgorithmUUID", os, indent + 1);
}

template <>
inline void Print<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV>(VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.shaderSMBuiltins, "VkBool32 shaderSMBuiltins", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV>(VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.shaderSMCount, "uint32_t shaderSMCount", os, indent +1);
    Print(src.shaderWarpsPerSM, "uint32_t shaderWarpsPerSM", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures>(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.shaderSubgroupExtendedTypes, "VkBool32 shaderSubgroupExtendedTypes", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR>(VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.shaderSubgroupUniformControlFlow, "VkBool32 shaderSubgroupUniformControlFlow", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceShaderTerminateInvocationFeatures>(VkPhysicalDeviceShaderTerminateInvocationFeatures const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.shaderTerminateInvocation, "VkBool32 shaderTerminateInvocation", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceShadingRateImageFeaturesNV>(VkPhysicalDeviceShadingRateImageFeaturesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.shadingRateImage, "VkBool32 shadingRateImage", os, indent +1);
    Print(src.shadingRateCoarseSampleOrder, "VkBool32 shadingRateCoarseSampleOrder", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceShadingRateImagePropertiesNV>(VkPhysicalDeviceShadingRateImagePropertiesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.shadingRateTexelSize, "VkExtent2D shadingRateTexelSize", os, indent +1);
    Print(src.shadingRatePaletteSize, "uint32_t shadingRatePaletteSize", os, indent +1);
    Print(src.shadingRateMaxCoarseSamples, "uint32_t shadingRateMaxCoarseSamples", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceSparseImageFormatInfo2>(VkPhysicalDeviceSparseImageFormatInfo2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.format, "VkFormat format", os, indent +1);
    Print(src.type, "VkImageType type", os, indent +1);
    Print(src.samples, "VkSampleCountFlagBits samples", os, indent +1);
    Print(src.usage, "VkImageUsageFlags usage", os, indent +1);
    Print(src.tiling, "VkImageTiling tiling", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceSparseProperties>(VkPhysicalDeviceSparseProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.residencyStandard2DBlockShape, "VkBool32 residencyStandard2DBlockShape", os, indent +1);
    Print(src.residencyStandard2DMultisampleBlockShape, "VkBool32 residencyStandard2DMultisampleBlockShape", os, indent +1);
    Print(src.residencyStandard3DBlockShape, "VkBool32 residencyStandard3DBlockShape", os, indent +1);
    Print(src.residencyAlignedMipSize, "VkBool32 residencyAlignedMipSize", os, indent +1);
    Print(src.residencyNonResidentStrict, "VkBool32 residencyNonResidentStrict", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceSubgroupProperties>(VkPhysicalDeviceSubgroupProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.subgroupSize, "uint32_t subgroupSize", os, indent +1);
    Print(src.supportedStages, "VkShaderStageFlags supportedStages", os, indent +1);
    Print(src.supportedOperations, "VkSubgroupFeatureFlags supportedOperations", os, indent +1);
    Print(src.quadOperationsInAllStages, "VkBool32 quadOperationsInAllStages", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceSubgroupSizeControlFeatures>(VkPhysicalDeviceSubgroupSizeControlFeatures const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.subgroupSizeControl, "VkBool32 subgroupSizeControl", os, indent +1);
    Print(src.computeFullSubgroups, "VkBool32 computeFullSubgroups", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceSubgroupSizeControlProperties>(VkPhysicalDeviceSubgroupSizeControlProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.minSubgroupSize, "uint32_t minSubgroupSize", os, indent +1);
    Print(src.maxSubgroupSize, "uint32_t maxSubgroupSize", os, indent +1);
    Print(src.maxComputeWorkgroupSubgroups, "uint32_t maxComputeWorkgroupSubgroups", os, indent +1);
    Print(src.requiredSubgroupSizeStages, "VkShaderStageFlags requiredSubgroupSizeStages", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT>(VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.subpassMergeFeedback, "VkBool32 subpassMergeFeedback", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceSubpassShadingFeaturesHUAWEI>(VkPhysicalDeviceSubpassShadingFeaturesHUAWEI const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.subpassShading, "VkBool32 subpassShading", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceSubpassShadingPropertiesHUAWEI>(VkPhysicalDeviceSubpassShadingPropertiesHUAWEI const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.maxSubpassShadingWorkgroupSizeAspectRatio, "uint32_t maxSubpassShadingWorkgroupSizeAspectRatio", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceSurfaceInfo2KHR>(VkPhysicalDeviceSurfaceInfo2KHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.surface, "VkSurfaceKHR surface", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT>(VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.swapchainMaintenance1, "VkBool32 swapchainMaintenance1", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceSynchronization2Features>(VkPhysicalDeviceSynchronization2Features const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.synchronization2, "VkBool32 synchronization2", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT>(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.texelBufferAlignment, "VkBool32 texelBufferAlignment", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceTexelBufferAlignmentProperties>(VkPhysicalDeviceTexelBufferAlignmentProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.storageTexelBufferOffsetAlignmentBytes, "VkDeviceSize storageTexelBufferOffsetAlignmentBytes", os, indent +1);
    Print(src.storageTexelBufferOffsetSingleTexelAlignment, "VkBool32 storageTexelBufferOffsetSingleTexelAlignment", os, indent +1);
    Print(src.uniformTexelBufferOffsetAlignmentBytes, "VkDeviceSize uniformTexelBufferOffsetAlignmentBytes", os, indent +1);
    Print(src.uniformTexelBufferOffsetSingleTexelAlignment, "VkBool32 uniformTexelBufferOffsetSingleTexelAlignment", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceTextureCompressionASTCHDRFeatures>(VkPhysicalDeviceTextureCompressionASTCHDRFeatures const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.textureCompressionASTC_HDR, "VkBool32 textureCompressionASTC_HDR", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceTilePropertiesFeaturesQCOM>(VkPhysicalDeviceTilePropertiesFeaturesQCOM const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.tileProperties, "VkBool32 tileProperties", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceTimelineSemaphoreFeatures>(VkPhysicalDeviceTimelineSemaphoreFeatures const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.timelineSemaphore, "VkBool32 timelineSemaphore", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceTimelineSemaphoreProperties>(VkPhysicalDeviceTimelineSemaphoreProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.maxTimelineSemaphoreValueDifference, "uint64_t maxTimelineSemaphoreValueDifference", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceToolProperties>(VkPhysicalDeviceToolProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    PrintArray(src.name, 256, "char [256] name", os, indent + 1);
    PrintArray(src.version, 256, "char [256] version", os, indent + 1);
    Print(src.purposes, "VkToolPurposeFlags purposes", os, indent +1);
    PrintArray(src.description, 256, "char [256] description", os, indent + 1);
    PrintArray(src.layer, 256, "char [256] layer", os, indent + 1);
}

template <>
inline void Print<VkPhysicalDeviceTransformFeedbackFeaturesEXT>(VkPhysicalDeviceTransformFeedbackFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.transformFeedback, "VkBool32 transformFeedback", os, indent +1);
    Print(src.geometryStreams, "VkBool32 geometryStreams", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceTransformFeedbackPropertiesEXT>(VkPhysicalDeviceTransformFeedbackPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.maxTransformFeedbackStreams, "uint32_t maxTransformFeedbackStreams", os, indent +1);
    Print(src.maxTransformFeedbackBuffers, "uint32_t maxTransformFeedbackBuffers", os, indent +1);
    Print(src.maxTransformFeedbackBufferSize, "VkDeviceSize maxTransformFeedbackBufferSize", os, indent +1);
    Print(src.maxTransformFeedbackStreamDataSize, "uint32_t maxTransformFeedbackStreamDataSize", os, indent +1);
    Print(src.maxTransformFeedbackBufferDataSize, "uint32_t maxTransformFeedbackBufferDataSize", os, indent +1);
    Print(src.maxTransformFeedbackBufferDataStride, "uint32_t maxTransformFeedbackBufferDataStride", os, indent +1);
    Print(src.transformFeedbackQueries, "VkBool32 transformFeedbackQueries", os, indent +1);
    Print(src.transformFeedbackStreamsLinesTriangles, "VkBool32 transformFeedbackStreamsLinesTriangles", os, indent +1);
    Print(src.transformFeedbackRasterizationStreamSelect, "VkBool32 transformFeedbackRasterizationStreamSelect", os, indent +1);
    Print(src.transformFeedbackDraw, "VkBool32 transformFeedbackDraw", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceUniformBufferStandardLayoutFeatures>(VkPhysicalDeviceUniformBufferStandardLayoutFeatures const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.uniformBufferStandardLayout, "VkBool32 uniformBufferStandardLayout", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceVariablePointersFeatures>(VkPhysicalDeviceVariablePointersFeatures const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.variablePointersStorageBuffer, "VkBool32 variablePointersStorageBuffer", os, indent +1);
    Print(src.variablePointers, "VkBool32 variablePointers", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT>(VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.vertexAttributeInstanceRateDivisor, "VkBool32 vertexAttributeInstanceRateDivisor", os, indent +1);
    Print(src.vertexAttributeInstanceRateZeroDivisor, "VkBool32 vertexAttributeInstanceRateZeroDivisor", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT>(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.maxVertexAttribDivisor, "uint32_t maxVertexAttribDivisor", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT>(VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.vertexInputDynamicState, "VkBool32 vertexInputDynamicState", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceVideoFormatInfoKHR>(VkPhysicalDeviceVideoFormatInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.imageUsage, "VkImageUsageFlags imageUsage", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceVulkan11Features>(VkPhysicalDeviceVulkan11Features const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.storageBuffer16BitAccess, "VkBool32 storageBuffer16BitAccess", os, indent +1);
    Print(src.uniformAndStorageBuffer16BitAccess, "VkBool32 uniformAndStorageBuffer16BitAccess", os, indent +1);
    Print(src.storagePushConstant16, "VkBool32 storagePushConstant16", os, indent +1);
    Print(src.storageInputOutput16, "VkBool32 storageInputOutput16", os, indent +1);
    Print(src.multiview, "VkBool32 multiview", os, indent +1);
    Print(src.multiviewGeometryShader, "VkBool32 multiviewGeometryShader", os, indent +1);
    Print(src.multiviewTessellationShader, "VkBool32 multiviewTessellationShader", os, indent +1);
    Print(src.variablePointersStorageBuffer, "VkBool32 variablePointersStorageBuffer", os, indent +1);
    Print(src.variablePointers, "VkBool32 variablePointers", os, indent +1);
    Print(src.protectedMemory, "VkBool32 protectedMemory", os, indent +1);
    Print(src.samplerYcbcrConversion, "VkBool32 samplerYcbcrConversion", os, indent +1);
    Print(src.shaderDrawParameters, "VkBool32 shaderDrawParameters", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceVulkan11Properties>(VkPhysicalDeviceVulkan11Properties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    PrintArray(src.deviceUUID, 16, "uint8_t [16] deviceUUID", os, indent + 1);
    PrintArray(src.driverUUID, 16, "uint8_t [16] driverUUID", os, indent + 1);
    PrintArray(src.deviceLUID, 8, "uint8_t [8] deviceLUID", os, indent + 1);
    Print(src.deviceNodeMask, "uint32_t deviceNodeMask", os, indent +1);
    Print(src.deviceLUIDValid, "VkBool32 deviceLUIDValid", os, indent +1);
    Print(src.subgroupSize, "uint32_t subgroupSize", os, indent +1);
    Print(src.subgroupSupportedStages, "VkShaderStageFlags subgroupSupportedStages", os, indent +1);
    Print(src.subgroupSupportedOperations, "VkSubgroupFeatureFlags subgroupSupportedOperations", os, indent +1);
    Print(src.subgroupQuadOperationsInAllStages, "VkBool32 subgroupQuadOperationsInAllStages", os, indent +1);
    Print(src.pointClippingBehavior, "VkPointClippingBehavior pointClippingBehavior", os, indent +1);
    Print(src.maxMultiviewViewCount, "uint32_t maxMultiviewViewCount", os, indent +1);
    Print(src.maxMultiviewInstanceIndex, "uint32_t maxMultiviewInstanceIndex", os, indent +1);
    Print(src.protectedNoFault, "VkBool32 protectedNoFault", os, indent +1);
    Print(src.maxPerSetDescriptors, "uint32_t maxPerSetDescriptors", os, indent +1);
    Print(src.maxMemoryAllocationSize, "VkDeviceSize maxMemoryAllocationSize", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceVulkan12Features>(VkPhysicalDeviceVulkan12Features const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.samplerMirrorClampToEdge, "VkBool32 samplerMirrorClampToEdge", os, indent +1);
    Print(src.drawIndirectCount, "VkBool32 drawIndirectCount", os, indent +1);
    Print(src.storageBuffer8BitAccess, "VkBool32 storageBuffer8BitAccess", os, indent +1);
    Print(src.uniformAndStorageBuffer8BitAccess, "VkBool32 uniformAndStorageBuffer8BitAccess", os, indent +1);
    Print(src.storagePushConstant8, "VkBool32 storagePushConstant8", os, indent +1);
    Print(src.shaderBufferInt64Atomics, "VkBool32 shaderBufferInt64Atomics", os, indent +1);
    Print(src.shaderSharedInt64Atomics, "VkBool32 shaderSharedInt64Atomics", os, indent +1);
    Print(src.shaderFloat16, "VkBool32 shaderFloat16", os, indent +1);
    Print(src.shaderInt8, "VkBool32 shaderInt8", os, indent +1);
    Print(src.descriptorIndexing, "VkBool32 descriptorIndexing", os, indent +1);
    Print(src.shaderInputAttachmentArrayDynamicIndexing, "VkBool32 shaderInputAttachmentArrayDynamicIndexing", os, indent +1);
    Print(src.shaderUniformTexelBufferArrayDynamicIndexing, "VkBool32 shaderUniformTexelBufferArrayDynamicIndexing", os, indent +1);
    Print(src.shaderStorageTexelBufferArrayDynamicIndexing, "VkBool32 shaderStorageTexelBufferArrayDynamicIndexing", os, indent +1);
    Print(src.shaderUniformBufferArrayNonUniformIndexing, "VkBool32 shaderUniformBufferArrayNonUniformIndexing", os, indent +1);
    Print(src.shaderSampledImageArrayNonUniformIndexing, "VkBool32 shaderSampledImageArrayNonUniformIndexing", os, indent +1);
    Print(src.shaderStorageBufferArrayNonUniformIndexing, "VkBool32 shaderStorageBufferArrayNonUniformIndexing", os, indent +1);
    Print(src.shaderStorageImageArrayNonUniformIndexing, "VkBool32 shaderStorageImageArrayNonUniformIndexing", os, indent +1);
    Print(src.shaderInputAttachmentArrayNonUniformIndexing, "VkBool32 shaderInputAttachmentArrayNonUniformIndexing", os, indent +1);
    Print(src.shaderUniformTexelBufferArrayNonUniformIndexing, "VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing", os, indent +1);
    Print(src.shaderStorageTexelBufferArrayNonUniformIndexing, "VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing", os, indent +1);
    Print(src.descriptorBindingUniformBufferUpdateAfterBind, "VkBool32 descriptorBindingUniformBufferUpdateAfterBind", os, indent +1);
    Print(src.descriptorBindingSampledImageUpdateAfterBind, "VkBool32 descriptorBindingSampledImageUpdateAfterBind", os, indent +1);
    Print(src.descriptorBindingStorageImageUpdateAfterBind, "VkBool32 descriptorBindingStorageImageUpdateAfterBind", os, indent +1);
    Print(src.descriptorBindingStorageBufferUpdateAfterBind, "VkBool32 descriptorBindingStorageBufferUpdateAfterBind", os, indent +1);
    Print(src.descriptorBindingUniformTexelBufferUpdateAfterBind, "VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind", os, indent +1);
    Print(src.descriptorBindingStorageTexelBufferUpdateAfterBind, "VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind", os, indent +1);
    Print(src.descriptorBindingUpdateUnusedWhilePending, "VkBool32 descriptorBindingUpdateUnusedWhilePending", os, indent +1);
    Print(src.descriptorBindingPartiallyBound, "VkBool32 descriptorBindingPartiallyBound", os, indent +1);
    Print(src.descriptorBindingVariableDescriptorCount, "VkBool32 descriptorBindingVariableDescriptorCount", os, indent +1);
    Print(src.runtimeDescriptorArray, "VkBool32 runtimeDescriptorArray", os, indent +1);
    Print(src.samplerFilterMinmax, "VkBool32 samplerFilterMinmax", os, indent +1);
    Print(src.scalarBlockLayout, "VkBool32 scalarBlockLayout", os, indent +1);
    Print(src.imagelessFramebuffer, "VkBool32 imagelessFramebuffer", os, indent +1);
    Print(src.uniformBufferStandardLayout, "VkBool32 uniformBufferStandardLayout", os, indent +1);
    Print(src.shaderSubgroupExtendedTypes, "VkBool32 shaderSubgroupExtendedTypes", os, indent +1);
    Print(src.separateDepthStencilLayouts, "VkBool32 separateDepthStencilLayouts", os, indent +1);
    Print(src.hostQueryReset, "VkBool32 hostQueryReset", os, indent +1);
    Print(src.timelineSemaphore, "VkBool32 timelineSemaphore", os, indent +1);
    Print(src.bufferDeviceAddress, "VkBool32 bufferDeviceAddress", os, indent +1);
    Print(src.bufferDeviceAddressCaptureReplay, "VkBool32 bufferDeviceAddressCaptureReplay", os, indent +1);
    Print(src.bufferDeviceAddressMultiDevice, "VkBool32 bufferDeviceAddressMultiDevice", os, indent +1);
    Print(src.vulkanMemoryModel, "VkBool32 vulkanMemoryModel", os, indent +1);
    Print(src.vulkanMemoryModelDeviceScope, "VkBool32 vulkanMemoryModelDeviceScope", os, indent +1);
    Print(src.vulkanMemoryModelAvailabilityVisibilityChains, "VkBool32 vulkanMemoryModelAvailabilityVisibilityChains", os, indent +1);
    Print(src.shaderOutputViewportIndex, "VkBool32 shaderOutputViewportIndex", os, indent +1);
    Print(src.shaderOutputLayer, "VkBool32 shaderOutputLayer", os, indent +1);
    Print(src.subgroupBroadcastDynamicId, "VkBool32 subgroupBroadcastDynamicId", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceVulkan12Properties>(VkPhysicalDeviceVulkan12Properties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.driverID, "VkDriverId driverID", os, indent +1);
    PrintArray(src.driverName, 256, "char [256] driverName", os, indent + 1);
    PrintArray(src.driverInfo, 256, "char [256] driverInfo", os, indent + 1);
    Print(src.conformanceVersion, "VkConformanceVersion conformanceVersion", os, indent +1);
    Print(src.denormBehaviorIndependence, "VkShaderFloatControlsIndependence denormBehaviorIndependence", os, indent +1);
    Print(src.roundingModeIndependence, "VkShaderFloatControlsIndependence roundingModeIndependence", os, indent +1);
    Print(src.shaderSignedZeroInfNanPreserveFloat16, "VkBool32 shaderSignedZeroInfNanPreserveFloat16", os, indent +1);
    Print(src.shaderSignedZeroInfNanPreserveFloat32, "VkBool32 shaderSignedZeroInfNanPreserveFloat32", os, indent +1);
    Print(src.shaderSignedZeroInfNanPreserveFloat64, "VkBool32 shaderSignedZeroInfNanPreserveFloat64", os, indent +1);
    Print(src.shaderDenormPreserveFloat16, "VkBool32 shaderDenormPreserveFloat16", os, indent +1);
    Print(src.shaderDenormPreserveFloat32, "VkBool32 shaderDenormPreserveFloat32", os, indent +1);
    Print(src.shaderDenormPreserveFloat64, "VkBool32 shaderDenormPreserveFloat64", os, indent +1);
    Print(src.shaderDenormFlushToZeroFloat16, "VkBool32 shaderDenormFlushToZeroFloat16", os, indent +1);
    Print(src.shaderDenormFlushToZeroFloat32, "VkBool32 shaderDenormFlushToZeroFloat32", os, indent +1);
    Print(src.shaderDenormFlushToZeroFloat64, "VkBool32 shaderDenormFlushToZeroFloat64", os, indent +1);
    Print(src.shaderRoundingModeRTEFloat16, "VkBool32 shaderRoundingModeRTEFloat16", os, indent +1);
    Print(src.shaderRoundingModeRTEFloat32, "VkBool32 shaderRoundingModeRTEFloat32", os, indent +1);
    Print(src.shaderRoundingModeRTEFloat64, "VkBool32 shaderRoundingModeRTEFloat64", os, indent +1);
    Print(src.shaderRoundingModeRTZFloat16, "VkBool32 shaderRoundingModeRTZFloat16", os, indent +1);
    Print(src.shaderRoundingModeRTZFloat32, "VkBool32 shaderRoundingModeRTZFloat32", os, indent +1);
    Print(src.shaderRoundingModeRTZFloat64, "VkBool32 shaderRoundingModeRTZFloat64", os, indent +1);
    Print(src.maxUpdateAfterBindDescriptorsInAllPools, "uint32_t maxUpdateAfterBindDescriptorsInAllPools", os, indent +1);
    Print(src.shaderUniformBufferArrayNonUniformIndexingNative, "VkBool32 shaderUniformBufferArrayNonUniformIndexingNative", os, indent +1);
    Print(src.shaderSampledImageArrayNonUniformIndexingNative, "VkBool32 shaderSampledImageArrayNonUniformIndexingNative", os, indent +1);
    Print(src.shaderStorageBufferArrayNonUniformIndexingNative, "VkBool32 shaderStorageBufferArrayNonUniformIndexingNative", os, indent +1);
    Print(src.shaderStorageImageArrayNonUniformIndexingNative, "VkBool32 shaderStorageImageArrayNonUniformIndexingNative", os, indent +1);
    Print(src.shaderInputAttachmentArrayNonUniformIndexingNative, "VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative", os, indent +1);
    Print(src.robustBufferAccessUpdateAfterBind, "VkBool32 robustBufferAccessUpdateAfterBind", os, indent +1);
    Print(src.quadDivergentImplicitLod, "VkBool32 quadDivergentImplicitLod", os, indent +1);
    Print(src.maxPerStageDescriptorUpdateAfterBindSamplers, "uint32_t maxPerStageDescriptorUpdateAfterBindSamplers", os, indent +1);
    Print(src.maxPerStageDescriptorUpdateAfterBindUniformBuffers, "uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers", os, indent +1);
    Print(src.maxPerStageDescriptorUpdateAfterBindStorageBuffers, "uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers", os, indent +1);
    Print(src.maxPerStageDescriptorUpdateAfterBindSampledImages, "uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages", os, indent +1);
    Print(src.maxPerStageDescriptorUpdateAfterBindStorageImages, "uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages", os, indent +1);
    Print(src.maxPerStageDescriptorUpdateAfterBindInputAttachments, "uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments", os, indent +1);
    Print(src.maxPerStageUpdateAfterBindResources, "uint32_t maxPerStageUpdateAfterBindResources", os, indent +1);
    Print(src.maxDescriptorSetUpdateAfterBindSamplers, "uint32_t maxDescriptorSetUpdateAfterBindSamplers", os, indent +1);
    Print(src.maxDescriptorSetUpdateAfterBindUniformBuffers, "uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers", os, indent +1);
    Print(src.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, "uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", os, indent +1);
    Print(src.maxDescriptorSetUpdateAfterBindStorageBuffers, "uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers", os, indent +1);
    Print(src.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, "uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", os, indent +1);
    Print(src.maxDescriptorSetUpdateAfterBindSampledImages, "uint32_t maxDescriptorSetUpdateAfterBindSampledImages", os, indent +1);
    Print(src.maxDescriptorSetUpdateAfterBindStorageImages, "uint32_t maxDescriptorSetUpdateAfterBindStorageImages", os, indent +1);
    Print(src.maxDescriptorSetUpdateAfterBindInputAttachments, "uint32_t maxDescriptorSetUpdateAfterBindInputAttachments", os, indent +1);
    Print(src.supportedDepthResolveModes, "VkResolveModeFlags supportedDepthResolveModes", os, indent +1);
    Print(src.supportedStencilResolveModes, "VkResolveModeFlags supportedStencilResolveModes", os, indent +1);
    Print(src.independentResolveNone, "VkBool32 independentResolveNone", os, indent +1);
    Print(src.independentResolve, "VkBool32 independentResolve", os, indent +1);
    Print(src.filterMinmaxSingleComponentFormats, "VkBool32 filterMinmaxSingleComponentFormats", os, indent +1);
    Print(src.filterMinmaxImageComponentMapping, "VkBool32 filterMinmaxImageComponentMapping", os, indent +1);
    Print(src.maxTimelineSemaphoreValueDifference, "uint64_t maxTimelineSemaphoreValueDifference", os, indent +1);
    Print(src.framebufferIntegerColorSampleCounts, "VkSampleCountFlags framebufferIntegerColorSampleCounts", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceVulkan13Features>(VkPhysicalDeviceVulkan13Features const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.robustImageAccess, "VkBool32 robustImageAccess", os, indent +1);
    Print(src.inlineUniformBlock, "VkBool32 inlineUniformBlock", os, indent +1);
    Print(src.descriptorBindingInlineUniformBlockUpdateAfterBind, "VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind", os, indent +1);
    Print(src.pipelineCreationCacheControl, "VkBool32 pipelineCreationCacheControl", os, indent +1);
    Print(src.privateData, "VkBool32 privateData", os, indent +1);
    Print(src.shaderDemoteToHelperInvocation, "VkBool32 shaderDemoteToHelperInvocation", os, indent +1);
    Print(src.shaderTerminateInvocation, "VkBool32 shaderTerminateInvocation", os, indent +1);
    Print(src.subgroupSizeControl, "VkBool32 subgroupSizeControl", os, indent +1);
    Print(src.computeFullSubgroups, "VkBool32 computeFullSubgroups", os, indent +1);
    Print(src.synchronization2, "VkBool32 synchronization2", os, indent +1);
    Print(src.textureCompressionASTC_HDR, "VkBool32 textureCompressionASTC_HDR", os, indent +1);
    Print(src.shaderZeroInitializeWorkgroupMemory, "VkBool32 shaderZeroInitializeWorkgroupMemory", os, indent +1);
    Print(src.dynamicRendering, "VkBool32 dynamicRendering", os, indent +1);
    Print(src.shaderIntegerDotProduct, "VkBool32 shaderIntegerDotProduct", os, indent +1);
    Print(src.maintenance4, "VkBool32 maintenance4", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceVulkan13Properties>(VkPhysicalDeviceVulkan13Properties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.minSubgroupSize, "uint32_t minSubgroupSize", os, indent +1);
    Print(src.maxSubgroupSize, "uint32_t maxSubgroupSize", os, indent +1);
    Print(src.maxComputeWorkgroupSubgroups, "uint32_t maxComputeWorkgroupSubgroups", os, indent +1);
    Print(src.requiredSubgroupSizeStages, "VkShaderStageFlags requiredSubgroupSizeStages", os, indent +1);
    Print(src.maxInlineUniformBlockSize, "uint32_t maxInlineUniformBlockSize", os, indent +1);
    Print(src.maxPerStageDescriptorInlineUniformBlocks, "uint32_t maxPerStageDescriptorInlineUniformBlocks", os, indent +1);
    Print(src.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks, "uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks", os, indent +1);
    Print(src.maxDescriptorSetInlineUniformBlocks, "uint32_t maxDescriptorSetInlineUniformBlocks", os, indent +1);
    Print(src.maxDescriptorSetUpdateAfterBindInlineUniformBlocks, "uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks", os, indent +1);
    Print(src.maxInlineUniformTotalSize, "uint32_t maxInlineUniformTotalSize", os, indent +1);
    Print(src.integerDotProduct8BitUnsignedAccelerated, "VkBool32 integerDotProduct8BitUnsignedAccelerated", os, indent +1);
    Print(src.integerDotProduct8BitSignedAccelerated, "VkBool32 integerDotProduct8BitSignedAccelerated", os, indent +1);
    Print(src.integerDotProduct8BitMixedSignednessAccelerated, "VkBool32 integerDotProduct8BitMixedSignednessAccelerated", os, indent +1);
    Print(src.integerDotProduct4x8BitPackedUnsignedAccelerated, "VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated", os, indent +1);
    Print(src.integerDotProduct4x8BitPackedSignedAccelerated, "VkBool32 integerDotProduct4x8BitPackedSignedAccelerated", os, indent +1);
    Print(src.integerDotProduct4x8BitPackedMixedSignednessAccelerated, "VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated", os, indent +1);
    Print(src.integerDotProduct16BitUnsignedAccelerated, "VkBool32 integerDotProduct16BitUnsignedAccelerated", os, indent +1);
    Print(src.integerDotProduct16BitSignedAccelerated, "VkBool32 integerDotProduct16BitSignedAccelerated", os, indent +1);
    Print(src.integerDotProduct16BitMixedSignednessAccelerated, "VkBool32 integerDotProduct16BitMixedSignednessAccelerated", os, indent +1);
    Print(src.integerDotProduct32BitUnsignedAccelerated, "VkBool32 integerDotProduct32BitUnsignedAccelerated", os, indent +1);
    Print(src.integerDotProduct32BitSignedAccelerated, "VkBool32 integerDotProduct32BitSignedAccelerated", os, indent +1);
    Print(src.integerDotProduct32BitMixedSignednessAccelerated, "VkBool32 integerDotProduct32BitMixedSignednessAccelerated", os, indent +1);
    Print(src.integerDotProduct64BitUnsignedAccelerated, "VkBool32 integerDotProduct64BitUnsignedAccelerated", os, indent +1);
    Print(src.integerDotProduct64BitSignedAccelerated, "VkBool32 integerDotProduct64BitSignedAccelerated", os, indent +1);
    Print(src.integerDotProduct64BitMixedSignednessAccelerated, "VkBool32 integerDotProduct64BitMixedSignednessAccelerated", os, indent +1);
    Print(src.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated, "VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated", os, indent +1);
    Print(src.integerDotProductAccumulatingSaturating8BitSignedAccelerated, "VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated", os, indent +1);
    Print(src.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated, "VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated", os, indent +1);
    Print(src.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated, "VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated", os, indent +1);
    Print(src.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated, "VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated", os, indent +1);
    Print(src.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated, "VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated", os, indent +1);
    Print(src.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated, "VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated", os, indent +1);
    Print(src.integerDotProductAccumulatingSaturating16BitSignedAccelerated, "VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated", os, indent +1);
    Print(src.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated, "VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated", os, indent +1);
    Print(src.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated, "VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated", os, indent +1);
    Print(src.integerDotProductAccumulatingSaturating32BitSignedAccelerated, "VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated", os, indent +1);
    Print(src.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated, "VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated", os, indent +1);
    Print(src.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated, "VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated", os, indent +1);
    Print(src.integerDotProductAccumulatingSaturating64BitSignedAccelerated, "VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated", os, indent +1);
    Print(src.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated, "VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated", os, indent +1);
    Print(src.storageTexelBufferOffsetAlignmentBytes, "VkDeviceSize storageTexelBufferOffsetAlignmentBytes", os, indent +1);
    Print(src.storageTexelBufferOffsetSingleTexelAlignment, "VkBool32 storageTexelBufferOffsetSingleTexelAlignment", os, indent +1);
    Print(src.uniformTexelBufferOffsetAlignmentBytes, "VkDeviceSize uniformTexelBufferOffsetAlignmentBytes", os, indent +1);
    Print(src.uniformTexelBufferOffsetSingleTexelAlignment, "VkBool32 uniformTexelBufferOffsetSingleTexelAlignment", os, indent +1);
    Print(src.maxBufferSize, "VkDeviceSize maxBufferSize", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceVulkanMemoryModelFeatures>(VkPhysicalDeviceVulkanMemoryModelFeatures const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.vulkanMemoryModel, "VkBool32 vulkanMemoryModel", os, indent +1);
    Print(src.vulkanMemoryModelDeviceScope, "VkBool32 vulkanMemoryModelDeviceScope", os, indent +1);
    Print(src.vulkanMemoryModelAvailabilityVisibilityChains, "VkBool32 vulkanMemoryModelAvailabilityVisibilityChains", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR>(VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.workgroupMemoryExplicitLayout, "VkBool32 workgroupMemoryExplicitLayout", os, indent +1);
    Print(src.workgroupMemoryExplicitLayoutScalarBlockLayout, "VkBool32 workgroupMemoryExplicitLayoutScalarBlockLayout", os, indent +1);
    Print(src.workgroupMemoryExplicitLayout8BitAccess, "VkBool32 workgroupMemoryExplicitLayout8BitAccess", os, indent +1);
    Print(src.workgroupMemoryExplicitLayout16BitAccess, "VkBool32 workgroupMemoryExplicitLayout16BitAccess", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT>(VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.ycbcr2plane444Formats, "VkBool32 ycbcr2plane444Formats", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT>(VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.ycbcrImageArrays, "VkBool32 ycbcrImageArrays", os, indent +1);
}

template <>
inline void Print<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures>(VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.shaderZeroInitializeWorkgroupMemory, "VkBool32 shaderZeroInitializeWorkgroupMemory", os, indent +1);
}

template <>
inline void Print<VkPipelineCacheCreateInfo>(VkPipelineCacheCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkPipelineCacheCreateFlags flags", os, indent +1);
    Print(src.initialDataSize, "size_t initialDataSize", os, indent +1);
            if( src.initialDataSize == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to initialDataSize" << std::endl;
            } else {
        PrintPointer(src.pInitialData, "const void * pInitialData", os, indent +1);
            }

}

template <>
inline void Print<VkPipelineCacheHeaderVersionOne>(VkPipelineCacheHeaderVersionOne const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.headerSize, "uint32_t headerSize", os, indent +1);
    Print(src.headerVersion, "VkPipelineCacheHeaderVersion headerVersion", os, indent +1);
    Print(src.vendorID, "uint32_t vendorID", os, indent +1);
    Print(src.deviceID, "uint32_t deviceID", os, indent +1);
    PrintArray(src.pipelineCacheUUID, 16, "uint8_t [16] pipelineCacheUUID", os, indent + 1);
}

template <>
inline void Print<VkPipelineColorBlendAdvancedStateCreateInfoEXT>(VkPipelineColorBlendAdvancedStateCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.srcPremultiplied, "VkBool32 srcPremultiplied", os, indent +1);
    Print(src.dstPremultiplied, "VkBool32 dstPremultiplied", os, indent +1);
    Print(src.blendOverlap, "VkBlendOverlapEXT blendOverlap", os, indent +1);
}

template <>
inline void Print<VkPipelineColorBlendAttachmentState>(VkPipelineColorBlendAttachmentState const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.blendEnable, "VkBool32 blendEnable", os, indent +1);
    Print(src.srcColorBlendFactor, "VkBlendFactor srcColorBlendFactor", os, indent +1);
    Print(src.dstColorBlendFactor, "VkBlendFactor dstColorBlendFactor", os, indent +1);
    Print(src.colorBlendOp, "VkBlendOp colorBlendOp", os, indent +1);
    Print(src.srcAlphaBlendFactor, "VkBlendFactor srcAlphaBlendFactor", os, indent +1);
    Print(src.dstAlphaBlendFactor, "VkBlendFactor dstAlphaBlendFactor", os, indent +1);
    Print(src.alphaBlendOp, "VkBlendOp alphaBlendOp", os, indent +1);
    Print(src.colorWriteMask, "VkColorComponentFlags colorWriteMask", os, indent +1);
}

template <>
inline void Print<VkPipelineColorBlendStateCreateInfo>(VkPipelineColorBlendStateCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkPipelineColorBlendStateCreateFlags flags", os, indent +1);
    Print(src.logicOpEnable, "VkBool32 logicOpEnable", os, indent +1);
    Print(src.logicOp, "VkLogicOp logicOp", os, indent +1);
    Print(src.attachmentCount, "uint32_t attachmentCount", os, indent +1);
            if( src.attachmentCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to attachmentCount" << std::endl;
            } else {
        PrintPointer(src.pAttachments, "const VkPipelineColorBlendAttachmentState * pAttachments", os, indent +1);
            }

    PrintArray(src.blendConstants, 4, "float [4] blendConstants", os, indent + 1);
}

template <>
inline void Print<VkPipelineColorWriteCreateInfoEXT>(VkPipelineColorWriteCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.attachmentCount, "uint32_t attachmentCount", os, indent +1);
            if( src.attachmentCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to attachmentCount" << std::endl;
            } else {
        PrintPointer(src.pColorWriteEnables, "const VkBool32 * pColorWriteEnables", os, indent +1);
            }

}

template <>
inline void Print<VkPipelineCompilerControlCreateInfoAMD>(VkPipelineCompilerControlCreateInfoAMD const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.compilerControlFlags, "VkPipelineCompilerControlFlagsAMD compilerControlFlags", os, indent +1);
}

template <>
inline void Print<VkPipelineCoverageModulationStateCreateInfoNV>(VkPipelineCoverageModulationStateCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkPipelineCoverageModulationStateCreateFlagsNV flags", os, indent +1);
    Print(src.coverageModulationMode, "VkCoverageModulationModeNV coverageModulationMode", os, indent +1);
    Print(src.coverageModulationTableEnable, "VkBool32 coverageModulationTableEnable", os, indent +1);
    Print(src.coverageModulationTableCount, "uint32_t coverageModulationTableCount", os, indent +1);
            if( src.coverageModulationTableCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to coverageModulationTableCount" << std::endl;
            } else {
        PrintPointer(src.pCoverageModulationTable, "const float * pCoverageModulationTable", os, indent +1);
            }

}

template <>
inline void Print<VkPipelineCoverageReductionStateCreateInfoNV>(VkPipelineCoverageReductionStateCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkPipelineCoverageReductionStateCreateFlagsNV flags", os, indent +1);
    Print(src.coverageReductionMode, "VkCoverageReductionModeNV coverageReductionMode", os, indent +1);
}

template <>
inline void Print<VkPipelineCoverageToColorStateCreateInfoNV>(VkPipelineCoverageToColorStateCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkPipelineCoverageToColorStateCreateFlagsNV flags", os, indent +1);
    Print(src.coverageToColorEnable, "VkBool32 coverageToColorEnable", os, indent +1);
    Print(src.coverageToColorLocation, "uint32_t coverageToColorLocation", os, indent +1);
}

template <>
inline void Print<VkPipelineCreationFeedback>(VkPipelineCreationFeedback const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.flags, "VkPipelineCreationFeedbackFlags flags", os, indent +1);
    Print(src.duration, "uint64_t duration", os, indent +1);
}

template <>
inline void Print<VkPipelineCreationFeedbackCreateInfo>(VkPipelineCreationFeedbackCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintPointer(src.pPipelineCreationFeedback, "VkPipelineCreationFeedback * pPipelineCreationFeedback", os, indent +1);
    Print(src.pipelineStageCreationFeedbackCount, "uint32_t pipelineStageCreationFeedbackCount", os, indent +1);
            if( src.pipelineStageCreationFeedbackCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to pipelineStageCreationFeedbackCount" << std::endl;
            } else {
        PrintPointer(src.pPipelineStageCreationFeedbacks, "VkPipelineCreationFeedback * pPipelineStageCreationFeedbacks", os, indent +1);
            }

}

template <>
inline void Print<VkPipelineDepthStencilStateCreateInfo>(VkPipelineDepthStencilStateCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkPipelineDepthStencilStateCreateFlags flags", os, indent +1);
    Print(src.depthTestEnable, "VkBool32 depthTestEnable", os, indent +1);
    Print(src.depthWriteEnable, "VkBool32 depthWriteEnable", os, indent +1);
    Print(src.depthCompareOp, "VkCompareOp depthCompareOp", os, indent +1);
    Print(src.depthBoundsTestEnable, "VkBool32 depthBoundsTestEnable", os, indent +1);
    Print(src.stencilTestEnable, "VkBool32 stencilTestEnable", os, indent +1);
    Print(src.front, "VkStencilOpState front", os, indent +1);
    Print(src.back, "VkStencilOpState back", os, indent +1);
    Print(src.minDepthBounds, "float minDepthBounds", os, indent +1);
    Print(src.maxDepthBounds, "float maxDepthBounds", os, indent +1);
}

template <>
inline void Print<VkPipelineDiscardRectangleStateCreateInfoEXT>(VkPipelineDiscardRectangleStateCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkPipelineDiscardRectangleStateCreateFlagsEXT flags", os, indent +1);
    Print(src.discardRectangleMode, "VkDiscardRectangleModeEXT discardRectangleMode", os, indent +1);
    Print(src.discardRectangleCount, "uint32_t discardRectangleCount", os, indent +1);
            if( src.discardRectangleCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to discardRectangleCount" << std::endl;
            } else {
        PrintPointer(src.pDiscardRectangles, "const VkRect2D * pDiscardRectangles", os, indent +1);
            }

}

template <>
inline void Print<VkPipelineDynamicStateCreateInfo>(VkPipelineDynamicStateCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkPipelineDynamicStateCreateFlags flags", os, indent +1);
    Print(src.dynamicStateCount, "uint32_t dynamicStateCount", os, indent +1);
            if( src.dynamicStateCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to dynamicStateCount" << std::endl;
            } else {
        PrintPointer(src.pDynamicStates, "const VkDynamicState * pDynamicStates", os, indent +1);
            }

}

template <>
inline void Print<VkPipelineExecutableInfoKHR>(VkPipelineExecutableInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.pipeline, "VkPipeline pipeline", os, indent +1);
    Print(src.executableIndex, "uint32_t executableIndex", os, indent +1);
}

template <>
inline void Print<VkPipelineExecutableInternalRepresentationKHR>(VkPipelineExecutableInternalRepresentationKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    PrintArray(src.name, 256, "char [256] name", os, indent + 1);
    PrintArray(src.description, 256, "char [256] description", os, indent + 1);
    Print(src.isText, "VkBool32 isText", os, indent +1);
    Print(src.dataSize, "size_t dataSize", os, indent +1);
            if( src.dataSize == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to dataSize" << std::endl;
            } else {
        PrintPointer(src.pData, "void * pData", os, indent +1);
            }

}

template <>
inline void Print<VkPipelineExecutablePropertiesKHR>(VkPipelineExecutablePropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.stages, "VkShaderStageFlags stages", os, indent +1);
    PrintArray(src.name, 256, "char [256] name", os, indent + 1);
    PrintArray(src.description, 256, "char [256] description", os, indent + 1);
    Print(src.subgroupSize, "uint32_t subgroupSize", os, indent +1);
}

template <>
inline void Print<VkPipelineExecutableStatisticKHR>(VkPipelineExecutableStatisticKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    PrintArray(src.name, 256, "char [256] name", os, indent + 1);
    PrintArray(src.description, 256, "char [256] description", os, indent + 1);
    Print(src.format, "VkPipelineExecutableStatisticFormatKHR format", os, indent +1);
        // handle union value
}

template <>
inline void Print<VkPipelineFragmentShadingRateEnumStateCreateInfoNV>(VkPipelineFragmentShadingRateEnumStateCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.shadingRateType, "VkFragmentShadingRateTypeNV shadingRateType", os, indent +1);
    Print(src.shadingRate, "VkFragmentShadingRateNV shadingRate", os, indent +1);
    PrintArray(src.combinerOps, 2, "VkFragmentShadingRateCombinerOpKHR [2] combinerOps", os, indent + 1);
}

template <>
inline void Print<VkPipelineFragmentShadingRateStateCreateInfoKHR>(VkPipelineFragmentShadingRateStateCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.fragmentSize, "VkExtent2D fragmentSize", os, indent +1);
    PrintArray(src.combinerOps, 2, "VkFragmentShadingRateCombinerOpKHR [2] combinerOps", os, indent + 1);
}

template <>
inline void Print<VkPipelineInfoKHR>(VkPipelineInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.pipeline, "VkPipeline pipeline", os, indent +1);
}

template <>
inline void Print<VkPipelineInputAssemblyStateCreateInfo>(VkPipelineInputAssemblyStateCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkPipelineInputAssemblyStateCreateFlags flags", os, indent +1);
    Print(src.topology, "VkPrimitiveTopology topology", os, indent +1);
    Print(src.primitiveRestartEnable, "VkBool32 primitiveRestartEnable", os, indent +1);
}

template <>
inline void Print<VkPipelineLayoutCreateInfo>(VkPipelineLayoutCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkPipelineLayoutCreateFlags flags", os, indent +1);
    Print(src.setLayoutCount, "uint32_t setLayoutCount", os, indent +1);
            if( src.setLayoutCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to setLayoutCount" << std::endl;
            } else {
        PrintPointer(src.pSetLayouts, "const VkDescriptorSetLayout * pSetLayouts", os, indent +1);
            }

    Print(src.pushConstantRangeCount, "uint32_t pushConstantRangeCount", os, indent +1);
            if( src.pushConstantRangeCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to pushConstantRangeCount" << std::endl;
            } else {
        PrintPointer(src.pPushConstantRanges, "const VkPushConstantRange * pPushConstantRanges", os, indent +1);
            }

}

template <>
inline void Print<VkPipelineLibraryCreateInfoKHR>(VkPipelineLibraryCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.libraryCount, "uint32_t libraryCount", os, indent +1);
            if( src.libraryCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to libraryCount" << std::endl;
            } else {
        PrintPointer(src.pLibraries, "const VkPipeline * pLibraries", os, indent +1);
            }

}

template <>
inline void Print<VkPipelineMultisampleStateCreateInfo>(VkPipelineMultisampleStateCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkPipelineMultisampleStateCreateFlags flags", os, indent +1);
    Print(src.rasterizationSamples, "VkSampleCountFlagBits rasterizationSamples", os, indent +1);
    Print(src.sampleShadingEnable, "VkBool32 sampleShadingEnable", os, indent +1);
    Print(src.minSampleShading, "float minSampleShading", os, indent +1);
            if( src.rasterizationSamples == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to rasterizationSamples" << std::endl;
            } else {
        PrintPointer(src.pSampleMask, "const VkSampleMask * pSampleMask", os, indent +1);
            }

    Print(src.alphaToCoverageEnable, "VkBool32 alphaToCoverageEnable", os, indent +1);
    Print(src.alphaToOneEnable, "VkBool32 alphaToOneEnable", os, indent +1);
}

template <>
inline void Print<VkPipelinePropertiesIdentifierEXT>(VkPipelinePropertiesIdentifierEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    PrintArray(src.pipelineIdentifier, 16, "uint8_t [16] pipelineIdentifier", os, indent + 1);
}

template <>
inline void Print<VkPipelineRasterizationConservativeStateCreateInfoEXT>(VkPipelineRasterizationConservativeStateCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkPipelineRasterizationConservativeStateCreateFlagsEXT flags", os, indent +1);
    Print(src.conservativeRasterizationMode, "VkConservativeRasterizationModeEXT conservativeRasterizationMode", os, indent +1);
    Print(src.extraPrimitiveOverestimationSize, "float extraPrimitiveOverestimationSize", os, indent +1);
}

template <>
inline void Print<VkPipelineRasterizationDepthClipStateCreateInfoEXT>(VkPipelineRasterizationDepthClipStateCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags", os, indent +1);
    Print(src.depthClipEnable, "VkBool32 depthClipEnable", os, indent +1);
}

template <>
inline void Print<VkPipelineRasterizationLineStateCreateInfoEXT>(VkPipelineRasterizationLineStateCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.lineRasterizationMode, "VkLineRasterizationModeEXT lineRasterizationMode", os, indent +1);
    Print(src.stippledLineEnable, "VkBool32 stippledLineEnable", os, indent +1);
    Print(src.lineStippleFactor, "uint32_t lineStippleFactor", os, indent +1);
    Print(src.lineStipplePattern, "uint16_t lineStipplePattern", os, indent +1);
}

template <>
inline void Print<VkPipelineRasterizationProvokingVertexStateCreateInfoEXT>(VkPipelineRasterizationProvokingVertexStateCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.provokingVertexMode, "VkProvokingVertexModeEXT provokingVertexMode", os, indent +1);
}

template <>
inline void Print<VkPipelineRasterizationStateCreateInfo>(VkPipelineRasterizationStateCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkPipelineRasterizationStateCreateFlags flags", os, indent +1);
    Print(src.depthClampEnable, "VkBool32 depthClampEnable", os, indent +1);
    Print(src.rasterizerDiscardEnable, "VkBool32 rasterizerDiscardEnable", os, indent +1);
    Print(src.polygonMode, "VkPolygonMode polygonMode", os, indent +1);
    Print(src.cullMode, "VkCullModeFlags cullMode", os, indent +1);
    Print(src.frontFace, "VkFrontFace frontFace", os, indent +1);
    Print(src.depthBiasEnable, "VkBool32 depthBiasEnable", os, indent +1);
    Print(src.depthBiasConstantFactor, "float depthBiasConstantFactor", os, indent +1);
    Print(src.depthBiasClamp, "float depthBiasClamp", os, indent +1);
    Print(src.depthBiasSlopeFactor, "float depthBiasSlopeFactor", os, indent +1);
    Print(src.lineWidth, "float lineWidth", os, indent +1);
}

template <>
inline void Print<VkPipelineRasterizationStateRasterizationOrderAMD>(VkPipelineRasterizationStateRasterizationOrderAMD const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.rasterizationOrder, "VkRasterizationOrderAMD rasterizationOrder", os, indent +1);
}

template <>
inline void Print<VkPipelineRasterizationStateStreamCreateInfoEXT>(VkPipelineRasterizationStateStreamCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkPipelineRasterizationStateStreamCreateFlagsEXT flags", os, indent +1);
    Print(src.rasterizationStream, "uint32_t rasterizationStream", os, indent +1);
}

template <>
inline void Print<VkPipelineRenderingCreateInfo>(VkPipelineRenderingCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.viewMask, "uint32_t viewMask", os, indent +1);
    Print(src.colorAttachmentCount, "uint32_t colorAttachmentCount", os, indent +1);
            if( src.colorAttachmentCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to colorAttachmentCount" << std::endl;
            } else {
        PrintPointer(src.pColorAttachmentFormats, "const VkFormat * pColorAttachmentFormats", os, indent +1);
            }

    Print(src.depthAttachmentFormat, "VkFormat depthAttachmentFormat", os, indent +1);
    Print(src.stencilAttachmentFormat, "VkFormat stencilAttachmentFormat", os, indent +1);
}

template <>
inline void Print<VkPipelineRepresentativeFragmentTestStateCreateInfoNV>(VkPipelineRepresentativeFragmentTestStateCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.representativeFragmentTestEnable, "VkBool32 representativeFragmentTestEnable", os, indent +1);
}

template <>
inline void Print<VkPipelineRobustnessCreateInfoEXT>(VkPipelineRobustnessCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.storageBuffers, "VkPipelineRobustnessBufferBehaviorEXT storageBuffers", os, indent +1);
    Print(src.uniformBuffers, "VkPipelineRobustnessBufferBehaviorEXT uniformBuffers", os, indent +1);
    Print(src.vertexInputs, "VkPipelineRobustnessBufferBehaviorEXT vertexInputs", os, indent +1);
    Print(src.images, "VkPipelineRobustnessImageBehaviorEXT images", os, indent +1);
}

template <>
inline void Print<VkPipelineSampleLocationsStateCreateInfoEXT>(VkPipelineSampleLocationsStateCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.sampleLocationsEnable, "VkBool32 sampleLocationsEnable", os, indent +1);
    Print(src.sampleLocationsInfo, "VkSampleLocationsInfoEXT sampleLocationsInfo", os, indent +1);
}

template <>
inline void Print<VkPipelineShaderStageCreateInfo>(VkPipelineShaderStageCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkPipelineShaderStageCreateFlags flags", os, indent +1);
    Print(src.stage, "VkShaderStageFlagBits stage", os, indent +1);
        PrintInterfacePointer(src.module, "VkShaderModule module", os, indent +1);
        PrintPointer(src.pName, "const char * pName", os, indent +1);
        PrintPointer(src.pSpecializationInfo, "const VkSpecializationInfo * pSpecializationInfo", os, indent +1);
}

template <>
inline void Print<VkPipelineShaderStageModuleIdentifierCreateInfoEXT>(VkPipelineShaderStageModuleIdentifierCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.identifierSize, "uint32_t identifierSize", os, indent +1);
            if( src.identifierSize == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to identifierSize" << std::endl;
            } else {
        PrintPointer(src.pIdentifier, "const uint8_t * pIdentifier", os, indent +1);
            }

}

template <>
inline void Print<VkPipelineShaderStageRequiredSubgroupSizeCreateInfo>(VkPipelineShaderStageRequiredSubgroupSizeCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.requiredSubgroupSize, "uint32_t requiredSubgroupSize", os, indent +1);
}

template <>
inline void Print<VkPipelineTessellationDomainOriginStateCreateInfo>(VkPipelineTessellationDomainOriginStateCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.domainOrigin, "VkTessellationDomainOrigin domainOrigin", os, indent +1);
}

template <>
inline void Print<VkPipelineTessellationStateCreateInfo>(VkPipelineTessellationStateCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkPipelineTessellationStateCreateFlags flags", os, indent +1);
    Print(src.patchControlPoints, "uint32_t patchControlPoints", os, indent +1);
}

template <>
inline void Print<VkPipelineVertexInputDivisorStateCreateInfoEXT>(VkPipelineVertexInputDivisorStateCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.vertexBindingDivisorCount, "uint32_t vertexBindingDivisorCount", os, indent +1);
            if( src.vertexBindingDivisorCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to vertexBindingDivisorCount" << std::endl;
            } else {
        PrintPointer(src.pVertexBindingDivisors, "const VkVertexInputBindingDivisorDescriptionEXT * pVertexBindingDivisors", os, indent +1);
            }

}

template <>
inline void Print<VkPipelineVertexInputStateCreateInfo>(VkPipelineVertexInputStateCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkPipelineVertexInputStateCreateFlags flags", os, indent +1);
    Print(src.vertexBindingDescriptionCount, "uint32_t vertexBindingDescriptionCount", os, indent +1);
            if( src.vertexBindingDescriptionCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to vertexBindingDescriptionCount" << std::endl;
            } else {
        PrintPointer(src.pVertexBindingDescriptions, "const VkVertexInputBindingDescription * pVertexBindingDescriptions", os, indent +1);
            }

    Print(src.vertexAttributeDescriptionCount, "uint32_t vertexAttributeDescriptionCount", os, indent +1);
            if( src.vertexAttributeDescriptionCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to vertexAttributeDescriptionCount" << std::endl;
            } else {
        PrintPointer(src.pVertexAttributeDescriptions, "const VkVertexInputAttributeDescription * pVertexAttributeDescriptions", os, indent +1);
            }

}

template <>
inline void Print<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV>(VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.sampleOrderType, "VkCoarseSampleOrderTypeNV sampleOrderType", os, indent +1);
    Print(src.customSampleOrderCount, "uint32_t customSampleOrderCount", os, indent +1);
            if( src.customSampleOrderCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to customSampleOrderCount" << std::endl;
            } else {
        PrintPointer(src.pCustomSampleOrders, "const VkCoarseSampleOrderCustomNV * pCustomSampleOrders", os, indent +1);
            }

}

template <>
inline void Print<VkPipelineViewportDepthClipControlCreateInfoEXT>(VkPipelineViewportDepthClipControlCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.negativeOneToOne, "VkBool32 negativeOneToOne", os, indent +1);
}

template <>
inline void Print<VkPipelineViewportExclusiveScissorStateCreateInfoNV>(VkPipelineViewportExclusiveScissorStateCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.exclusiveScissorCount, "uint32_t exclusiveScissorCount", os, indent +1);
            if( src.exclusiveScissorCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to exclusiveScissorCount" << std::endl;
            } else {
        PrintPointer(src.pExclusiveScissors, "const VkRect2D * pExclusiveScissors", os, indent +1);
            }

}

template <>
inline void Print<VkPipelineViewportShadingRateImageStateCreateInfoNV>(VkPipelineViewportShadingRateImageStateCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.shadingRateImageEnable, "VkBool32 shadingRateImageEnable", os, indent +1);
    Print(src.viewportCount, "uint32_t viewportCount", os, indent +1);
            if( src.viewportCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to viewportCount" << std::endl;
            } else {
        PrintPointer(src.pShadingRatePalettes, "const VkShadingRatePaletteNV * pShadingRatePalettes", os, indent +1);
            }

}

template <>
inline void Print<VkPipelineViewportStateCreateInfo>(VkPipelineViewportStateCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkPipelineViewportStateCreateFlags flags", os, indent +1);
    Print(src.viewportCount, "uint32_t viewportCount", os, indent +1);
            if( src.viewportCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to viewportCount" << std::endl;
            } else {
        PrintPointer(src.pViewports, "const VkViewport * pViewports", os, indent +1);
            }

    Print(src.scissorCount, "uint32_t scissorCount", os, indent +1);
            if( src.scissorCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to scissorCount" << std::endl;
            } else {
        PrintPointer(src.pScissors, "const VkRect2D * pScissors", os, indent +1);
            }

}

template <>
inline void Print<VkPipelineViewportSwizzleStateCreateInfoNV>(VkPipelineViewportSwizzleStateCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkPipelineViewportSwizzleStateCreateFlagsNV flags", os, indent +1);
    Print(src.viewportCount, "uint32_t viewportCount", os, indent +1);
            if( src.viewportCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to viewportCount" << std::endl;
            } else {
        PrintPointer(src.pViewportSwizzles, "const VkViewportSwizzleNV * pViewportSwizzles", os, indent +1);
            }

}

template <>
inline void Print<VkPipelineViewportWScalingStateCreateInfoNV>(VkPipelineViewportWScalingStateCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.viewportWScalingEnable, "VkBool32 viewportWScalingEnable", os, indent +1);
    Print(src.viewportCount, "uint32_t viewportCount", os, indent +1);
            if( src.viewportCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to viewportCount" << std::endl;
            } else {
        PrintPointer(src.pViewportWScalings, "const VkViewportWScalingNV * pViewportWScalings", os, indent +1);
            }

}

template <>
inline void Print<VkPresentIdKHR>(VkPresentIdKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.swapchainCount, "uint32_t swapchainCount", os, indent +1);
            if( src.swapchainCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to swapchainCount" << std::endl;
            } else {
        PrintPointer(src.pPresentIds, "const uint64_t * pPresentIds", os, indent +1);
            }

}

template <>
inline void Print<VkPresentInfoKHR>(VkPresentInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.waitSemaphoreCount, "uint32_t waitSemaphoreCount", os, indent +1);
            if( src.waitSemaphoreCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to waitSemaphoreCount" << std::endl;
            } else {
        PrintPointer(src.pWaitSemaphores, "const VkSemaphore * pWaitSemaphores", os, indent +1);
            }

    Print(src.swapchainCount, "uint32_t swapchainCount", os, indent +1);
            if( src.swapchainCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to swapchainCount" << std::endl;
            } else {
        PrintPointer(src.pSwapchains, "const VkSwapchainKHR * pSwapchains", os, indent +1);
            }

            if( src.swapchainCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to swapchainCount" << std::endl;
            } else {
        PrintPointer(src.pImageIndices, "const uint32_t * pImageIndices", os, indent +1);
            }

            if( src.swapchainCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to swapchainCount" << std::endl;
            } else {
        PrintPointer(src.pResults, "VkResult * pResults", os, indent +1);
            }

}

template <>
inline void Print<VkPresentRegionKHR>(VkPresentRegionKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.rectangleCount, "uint32_t rectangleCount", os, indent +1);
            if( src.rectangleCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to rectangleCount" << std::endl;
            } else {
        PrintPointer(src.pRectangles, "const VkRectLayerKHR * pRectangles", os, indent +1);
            }

}

template <>
inline void Print<VkPresentRegionsKHR>(VkPresentRegionsKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.swapchainCount, "uint32_t swapchainCount", os, indent +1);
            if( src.swapchainCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to swapchainCount" << std::endl;
            } else {
        PrintPointer(src.pRegions, "const VkPresentRegionKHR * pRegions", os, indent +1);
            }

}

template <>
inline void Print<VkPresentTimeGOOGLE>(VkPresentTimeGOOGLE const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.presentID, "uint32_t presentID", os, indent +1);
    Print(src.desiredPresentTime, "uint64_t desiredPresentTime", os, indent +1);
}

template <>
inline void Print<VkPresentTimesInfoGOOGLE>(VkPresentTimesInfoGOOGLE const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.swapchainCount, "uint32_t swapchainCount", os, indent +1);
            if( src.swapchainCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to swapchainCount" << std::endl;
            } else {
        PrintPointer(src.pTimes, "const VkPresentTimeGOOGLE * pTimes", os, indent +1);
            }

}

template <>
inline void Print<VkPrivateDataSlotCreateInfo>(VkPrivateDataSlotCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkPrivateDataSlotCreateFlags flags", os, indent +1);
}

template <>
inline void Print<VkProtectedSubmitInfo>(VkProtectedSubmitInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.protectedSubmit, "VkBool32 protectedSubmit", os, indent +1);
}

template <>
inline void Print<VkPushConstantRange>(VkPushConstantRange const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.stageFlags, "VkShaderStageFlags stageFlags", os, indent +1);
    Print(src.offset, "uint32_t offset", os, indent +1);
    Print(src.size, "uint32_t size", os, indent +1);
}

template <>
inline void Print<VkQueryPoolCreateInfo>(VkQueryPoolCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkQueryPoolCreateFlags flags", os, indent +1);
    Print(src.queryType, "VkQueryType queryType", os, indent +1);
    Print(src.queryCount, "uint32_t queryCount", os, indent +1);
    Print(src.pipelineStatistics, "VkQueryPipelineStatisticFlags pipelineStatistics", os, indent +1);
}

template <>
inline void Print<VkQueryPoolPerformanceCreateInfoKHR>(VkQueryPoolPerformanceCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.queueFamilyIndex, "uint32_t queueFamilyIndex", os, indent +1);
    Print(src.counterIndexCount, "uint32_t counterIndexCount", os, indent +1);
            if( src.counterIndexCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to counterIndexCount" << std::endl;
            } else {
        PrintPointer(src.pCounterIndices, "const uint32_t * pCounterIndices", os, indent +1);
            }

}

template <>
inline void Print<VkQueryPoolPerformanceQueryCreateInfoINTEL>(VkQueryPoolPerformanceQueryCreateInfoINTEL const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.performanceCountersSampling, "VkQueryPoolSamplingModeINTEL performanceCountersSampling", os, indent +1);
}

template <>
inline void Print<VkQueueFamilyCheckpointProperties2NV>(VkQueueFamilyCheckpointProperties2NV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.checkpointExecutionStageMask, "VkPipelineStageFlags2 checkpointExecutionStageMask", os, indent +1);
}

template <>
inline void Print<VkQueueFamilyCheckpointPropertiesNV>(VkQueueFamilyCheckpointPropertiesNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.checkpointExecutionStageMask, "VkPipelineStageFlags checkpointExecutionStageMask", os, indent +1);
}

template <>
inline void Print<VkQueueFamilyGlobalPriorityPropertiesKHR>(VkQueueFamilyGlobalPriorityPropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.priorityCount, "uint32_t priorityCount", os, indent +1);
    PrintArray(src.priorities, 16, "VkQueueGlobalPriorityKHR [16] priorities", os, indent + 1);
}

template <>
inline void Print<VkQueueFamilyProperties>(VkQueueFamilyProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.queueFlags, "VkQueueFlags queueFlags", os, indent +1);
    Print(src.queueCount, "uint32_t queueCount", os, indent +1);
    Print(src.timestampValidBits, "uint32_t timestampValidBits", os, indent +1);
    Print(src.minImageTransferGranularity, "VkExtent3D minImageTransferGranularity", os, indent +1);
}

template <>
inline void Print<VkQueueFamilyProperties2>(VkQueueFamilyProperties2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.queueFamilyProperties, "VkQueueFamilyProperties queueFamilyProperties", os, indent +1);
}

template <>
inline void Print<VkQueueFamilyQueryResultStatusPropertiesKHR>(VkQueueFamilyQueryResultStatusPropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.queryResultStatusSupport, "VkBool32 queryResultStatusSupport", os, indent +1);
}

template <>
inline void Print<VkQueueFamilyVideoPropertiesKHR>(VkQueueFamilyVideoPropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.videoCodecOperations, "VkVideoCodecOperationFlagsKHR videoCodecOperations", os, indent +1);
}

template <>
inline void Print<VkRayTracingPipelineCreateInfoKHR>(VkRayTracingPipelineCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkPipelineCreateFlags flags", os, indent +1);
    Print(src.stageCount, "uint32_t stageCount", os, indent +1);
            if( src.stageCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to stageCount" << std::endl;
            } else {
        PrintPointer(src.pStages, "const VkPipelineShaderStageCreateInfo * pStages", os, indent +1);
            }

    Print(src.groupCount, "uint32_t groupCount", os, indent +1);
            if( src.groupCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to groupCount" << std::endl;
            } else {
        PrintPointer(src.pGroups, "const VkRayTracingShaderGroupCreateInfoKHR * pGroups", os, indent +1);
            }

    Print(src.maxPipelineRayRecursionDepth, "uint32_t maxPipelineRayRecursionDepth", os, indent +1);
        PrintPointer(src.pLibraryInfo, "const VkPipelineLibraryCreateInfoKHR * pLibraryInfo", os, indent +1);
        PrintPointer(src.pLibraryInterface, "const VkRayTracingPipelineInterfaceCreateInfoKHR * pLibraryInterface", os, indent +1);
        PrintPointer(src.pDynamicState, "const VkPipelineDynamicStateCreateInfo * pDynamicState", os, indent +1);
        PrintInterfacePointer(src.layout, "VkPipelineLayout layout", os, indent +1);
        PrintInterfacePointer(src.basePipelineHandle, "VkPipeline basePipelineHandle", os, indent +1);
    Print(src.basePipelineIndex, "int32_t basePipelineIndex", os, indent +1);
}

template <>
inline void Print<VkRayTracingPipelineCreateInfoNV>(VkRayTracingPipelineCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkPipelineCreateFlags flags", os, indent +1);
    Print(src.stageCount, "uint32_t stageCount", os, indent +1);
            if( src.stageCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to stageCount" << std::endl;
            } else {
        PrintPointer(src.pStages, "const VkPipelineShaderStageCreateInfo * pStages", os, indent +1);
            }

    Print(src.groupCount, "uint32_t groupCount", os, indent +1);
            if( src.groupCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to groupCount" << std::endl;
            } else {
        PrintPointer(src.pGroups, "const VkRayTracingShaderGroupCreateInfoNV * pGroups", os, indent +1);
            }

    Print(src.maxRecursionDepth, "uint32_t maxRecursionDepth", os, indent +1);
        PrintInterfacePointer(src.layout, "VkPipelineLayout layout", os, indent +1);
        PrintInterfacePointer(src.basePipelineHandle, "VkPipeline basePipelineHandle", os, indent +1);
    Print(src.basePipelineIndex, "int32_t basePipelineIndex", os, indent +1);
}

template <>
inline void Print<VkRayTracingPipelineInterfaceCreateInfoKHR>(VkRayTracingPipelineInterfaceCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.maxPipelineRayPayloadSize, "uint32_t maxPipelineRayPayloadSize", os, indent +1);
    Print(src.maxPipelineRayHitAttributeSize, "uint32_t maxPipelineRayHitAttributeSize", os, indent +1);
}

template <>
inline void Print<VkRayTracingShaderGroupCreateInfoKHR>(VkRayTracingShaderGroupCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.type, "VkRayTracingShaderGroupTypeKHR type", os, indent +1);
    Print(src.generalShader, "uint32_t generalShader", os, indent +1);
    Print(src.closestHitShader, "uint32_t closestHitShader", os, indent +1);
    Print(src.anyHitShader, "uint32_t anyHitShader", os, indent +1);
    Print(src.intersectionShader, "uint32_t intersectionShader", os, indent +1);
        PrintPointer(src.pShaderGroupCaptureReplayHandle, "const void * pShaderGroupCaptureReplayHandle", os, indent +1);
}

template <>
inline void Print<VkRayTracingShaderGroupCreateInfoNV>(VkRayTracingShaderGroupCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.type, "VkRayTracingShaderGroupTypeKHR type", os, indent +1);
    Print(src.generalShader, "uint32_t generalShader", os, indent +1);
    Print(src.closestHitShader, "uint32_t closestHitShader", os, indent +1);
    Print(src.anyHitShader, "uint32_t anyHitShader", os, indent +1);
    Print(src.intersectionShader, "uint32_t intersectionShader", os, indent +1);
}

template <>
inline void Print<VkRect2D>(VkRect2D const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.offset, "VkOffset2D offset", os, indent +1);
    Print(src.extent, "VkExtent2D extent", os, indent +1);
}

template <>
inline void Print<VkRectLayerKHR>(VkRectLayerKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.offset, "VkOffset2D offset", os, indent +1);
    Print(src.extent, "VkExtent2D extent", os, indent +1);
    Print(src.layer, "uint32_t layer", os, indent +1);
}

template <>
inline void Print<VkRefreshCycleDurationGOOGLE>(VkRefreshCycleDurationGOOGLE const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.refreshDuration, "uint64_t refreshDuration", os, indent +1);
}

template <>
inline void Print<VkReleaseSwapchainImagesInfoEXT>(VkReleaseSwapchainImagesInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.swapchain, "VkSwapchainKHR swapchain", os, indent +1);
    Print(src.imageIndexCount, "uint32_t imageIndexCount", os, indent +1);
            if( src.imageIndexCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to imageIndexCount" << std::endl;
            } else {
        PrintPointer(src.pImageIndices, "const uint32_t * pImageIndices", os, indent +1);
            }

}

template <>
inline void Print<VkRenderPassAttachmentBeginInfo>(VkRenderPassAttachmentBeginInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.attachmentCount, "uint32_t attachmentCount", os, indent +1);
            if( src.attachmentCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to attachmentCount" << std::endl;
            } else {
        PrintPointer(src.pAttachments, "const VkImageView * pAttachments", os, indent +1);
            }

}

template <>
inline void Print<VkRenderPassBeginInfo>(VkRenderPassBeginInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.renderPass, "VkRenderPass renderPass", os, indent +1);
        PrintInterfacePointer(src.framebuffer, "VkFramebuffer framebuffer", os, indent +1);
    Print(src.renderArea, "VkRect2D renderArea", os, indent +1);
    Print(src.clearValueCount, "uint32_t clearValueCount", os, indent +1);
            if( src.clearValueCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to clearValueCount" << std::endl;
            } else {
        PrintPointer(src.pClearValues, "const VkClearValue * pClearValues", os, indent +1);
            }

}

template <>
inline void Print<VkRenderPassCreateInfo>(VkRenderPassCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkRenderPassCreateFlags flags", os, indent +1);
    Print(src.attachmentCount, "uint32_t attachmentCount", os, indent +1);
            if( src.attachmentCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to attachmentCount" << std::endl;
            } else {
        PrintPointer(src.pAttachments, "const VkAttachmentDescription * pAttachments", os, indent +1);
            }

    Print(src.subpassCount, "uint32_t subpassCount", os, indent +1);
            if( src.subpassCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to subpassCount" << std::endl;
            } else {
        PrintPointer(src.pSubpasses, "const VkSubpassDescription * pSubpasses", os, indent +1);
            }

    Print(src.dependencyCount, "uint32_t dependencyCount", os, indent +1);
            if( src.dependencyCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to dependencyCount" << std::endl;
            } else {
        PrintPointer(src.pDependencies, "const VkSubpassDependency * pDependencies", os, indent +1);
            }

}

template <>
inline void Print<VkRenderPassCreateInfo2>(VkRenderPassCreateInfo2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkRenderPassCreateFlags flags", os, indent +1);
    Print(src.attachmentCount, "uint32_t attachmentCount", os, indent +1);
            if( src.attachmentCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to attachmentCount" << std::endl;
            } else {
        PrintPointer(src.pAttachments, "const VkAttachmentDescription2 * pAttachments", os, indent +1);
            }

    Print(src.subpassCount, "uint32_t subpassCount", os, indent +1);
            if( src.subpassCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to subpassCount" << std::endl;
            } else {
        PrintPointer(src.pSubpasses, "const VkSubpassDescription2 * pSubpasses", os, indent +1);
            }

    Print(src.dependencyCount, "uint32_t dependencyCount", os, indent +1);
            if( src.dependencyCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to dependencyCount" << std::endl;
            } else {
        PrintPointer(src.pDependencies, "const VkSubpassDependency2 * pDependencies", os, indent +1);
            }

    Print(src.correlatedViewMaskCount, "uint32_t correlatedViewMaskCount", os, indent +1);
            if( src.correlatedViewMaskCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to correlatedViewMaskCount" << std::endl;
            } else {
        PrintPointer(src.pCorrelatedViewMasks, "const uint32_t * pCorrelatedViewMasks", os, indent +1);
            }

}

template <>
inline void Print<VkRenderPassCreationControlEXT>(VkRenderPassCreationControlEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.disallowMerging, "VkBool32 disallowMerging", os, indent +1);
}

template <>
inline void Print<VkRenderPassCreationFeedbackCreateInfoEXT>(VkRenderPassCreationFeedbackCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintPointer(src.pRenderPassFeedback, "VkRenderPassCreationFeedbackInfoEXT * pRenderPassFeedback", os, indent +1);
}

template <>
inline void Print<VkRenderPassCreationFeedbackInfoEXT>(VkRenderPassCreationFeedbackInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.postMergeSubpassCount, "uint32_t postMergeSubpassCount", os, indent +1);
}

template <>
inline void Print<VkRenderPassFragmentDensityMapCreateInfoEXT>(VkRenderPassFragmentDensityMapCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.fragmentDensityMapAttachment, "VkAttachmentReference fragmentDensityMapAttachment", os, indent +1);
}

template <>
inline void Print<VkRenderPassInputAttachmentAspectCreateInfo>(VkRenderPassInputAttachmentAspectCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.aspectReferenceCount, "uint32_t aspectReferenceCount", os, indent +1);
            if( src.aspectReferenceCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to aspectReferenceCount" << std::endl;
            } else {
        PrintPointer(src.pAspectReferences, "const VkInputAttachmentAspectReference * pAspectReferences", os, indent +1);
            }

}

template <>
inline void Print<VkRenderPassMultiviewCreateInfo>(VkRenderPassMultiviewCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.subpassCount, "uint32_t subpassCount", os, indent +1);
            if( src.subpassCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to subpassCount" << std::endl;
            } else {
        PrintPointer(src.pViewMasks, "const uint32_t * pViewMasks", os, indent +1);
            }

    Print(src.dependencyCount, "uint32_t dependencyCount", os, indent +1);
            if( src.dependencyCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to dependencyCount" << std::endl;
            } else {
        PrintPointer(src.pViewOffsets, "const int32_t * pViewOffsets", os, indent +1);
            }

    Print(src.correlationMaskCount, "uint32_t correlationMaskCount", os, indent +1);
            if( src.correlationMaskCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to correlationMaskCount" << std::endl;
            } else {
        PrintPointer(src.pCorrelationMasks, "const uint32_t * pCorrelationMasks", os, indent +1);
            }

}

template <>
inline void Print<VkRenderPassSampleLocationsBeginInfoEXT>(VkRenderPassSampleLocationsBeginInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.attachmentInitialSampleLocationsCount, "uint32_t attachmentInitialSampleLocationsCount", os, indent +1);
            if( src.attachmentInitialSampleLocationsCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to attachmentInitialSampleLocationsCount" << std::endl;
            } else {
        PrintPointer(src.pAttachmentInitialSampleLocations, "const VkAttachmentSampleLocationsEXT * pAttachmentInitialSampleLocations", os, indent +1);
            }

    Print(src.postSubpassSampleLocationsCount, "uint32_t postSubpassSampleLocationsCount", os, indent +1);
            if( src.postSubpassSampleLocationsCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to postSubpassSampleLocationsCount" << std::endl;
            } else {
        PrintPointer(src.pPostSubpassSampleLocations, "const VkSubpassSampleLocationsEXT * pPostSubpassSampleLocations", os, indent +1);
            }

}

template <>
inline void Print<VkRenderPassSubpassFeedbackCreateInfoEXT>(VkRenderPassSubpassFeedbackCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintPointer(src.pSubpassFeedback, "VkRenderPassSubpassFeedbackInfoEXT * pSubpassFeedback", os, indent +1);
}

template <>
inline void Print<VkRenderPassSubpassFeedbackInfoEXT>(VkRenderPassSubpassFeedbackInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.subpassMergeStatus, "VkSubpassMergeStatusEXT subpassMergeStatus", os, indent +1);
    PrintArray(src.description, 256, "char [256] description", os, indent + 1);
    Print(src.postMergeIndex, "uint32_t postMergeIndex", os, indent +1);
}

template <>
inline void Print<VkRenderPassTransformBeginInfoQCOM>(VkRenderPassTransformBeginInfoQCOM const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.transform, "VkSurfaceTransformFlagBitsKHR transform", os, indent +1);
}

template <>
inline void Print<VkRenderingAttachmentInfo>(VkRenderingAttachmentInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.imageView, "VkImageView imageView", os, indent +1);
    Print(src.imageLayout, "VkImageLayout imageLayout", os, indent +1);
    Print(src.resolveMode, "VkResolveModeFlagBits resolveMode", os, indent +1);
        PrintInterfacePointer(src.resolveImageView, "VkImageView resolveImageView", os, indent +1);
    Print(src.resolveImageLayout, "VkImageLayout resolveImageLayout", os, indent +1);
    Print(src.loadOp, "VkAttachmentLoadOp loadOp", os, indent +1);
    Print(src.storeOp, "VkAttachmentStoreOp storeOp", os, indent +1);
        // handle union clearValue
}

template <>
inline void Print<VkRenderingFragmentDensityMapAttachmentInfoEXT>(VkRenderingFragmentDensityMapAttachmentInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.imageView, "VkImageView imageView", os, indent +1);
    Print(src.imageLayout, "VkImageLayout imageLayout", os, indent +1);
}

template <>
inline void Print<VkRenderingFragmentShadingRateAttachmentInfoKHR>(VkRenderingFragmentShadingRateAttachmentInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.imageView, "VkImageView imageView", os, indent +1);
    Print(src.imageLayout, "VkImageLayout imageLayout", os, indent +1);
    Print(src.shadingRateAttachmentTexelSize, "VkExtent2D shadingRateAttachmentTexelSize", os, indent +1);
}

template <>
inline void Print<VkRenderingInfo>(VkRenderingInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkRenderingFlags flags", os, indent +1);
    Print(src.renderArea, "VkRect2D renderArea", os, indent +1);
    Print(src.layerCount, "uint32_t layerCount", os, indent +1);
    Print(src.viewMask, "uint32_t viewMask", os, indent +1);
    Print(src.colorAttachmentCount, "uint32_t colorAttachmentCount", os, indent +1);
            if( src.colorAttachmentCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to colorAttachmentCount" << std::endl;
            } else {
        PrintPointer(src.pColorAttachments, "const VkRenderingAttachmentInfo * pColorAttachments", os, indent +1);
            }

        PrintPointer(src.pDepthAttachment, "const VkRenderingAttachmentInfo * pDepthAttachment", os, indent +1);
        PrintPointer(src.pStencilAttachment, "const VkRenderingAttachmentInfo * pStencilAttachment", os, indent +1);
}

template <>
inline void Print<VkResolveImageInfo2>(VkResolveImageInfo2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.srcImage, "VkImage srcImage", os, indent +1);
    Print(src.srcImageLayout, "VkImageLayout srcImageLayout", os, indent +1);
        PrintInterfacePointer(src.dstImage, "VkImage dstImage", os, indent +1);
    Print(src.dstImageLayout, "VkImageLayout dstImageLayout", os, indent +1);
    Print(src.regionCount, "uint32_t regionCount", os, indent +1);
            if( src.regionCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to regionCount" << std::endl;
            } else {
        PrintPointer(src.pRegions, "const VkImageResolve2 * pRegions", os, indent +1);
            }

}

template <>
inline void Print<VkSRTDataNV>(VkSRTDataNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sx, "float sx", os, indent +1);
    Print(src.a, "float a", os, indent +1);
    Print(src.b, "float b", os, indent +1);
    Print(src.pvx, "float pvx", os, indent +1);
    Print(src.sy, "float sy", os, indent +1);
    Print(src.c, "float c", os, indent +1);
    Print(src.pvy, "float pvy", os, indent +1);
    Print(src.sz, "float sz", os, indent +1);
    Print(src.pvz, "float pvz", os, indent +1);
    Print(src.qx, "float qx", os, indent +1);
    Print(src.qy, "float qy", os, indent +1);
    Print(src.qz, "float qz", os, indent +1);
    Print(src.qw, "float qw", os, indent +1);
    Print(src.tx, "float tx", os, indent +1);
    Print(src.ty, "float ty", os, indent +1);
    Print(src.tz, "float tz", os, indent +1);
}

template <>
inline void Print<VkSampleLocationEXT>(VkSampleLocationEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.x, "float x", os, indent +1);
    Print(src.y, "float y", os, indent +1);
}

template <>
inline void Print<VkSampleLocationsInfoEXT>(VkSampleLocationsInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.sampleLocationsPerPixel, "VkSampleCountFlagBits sampleLocationsPerPixel", os, indent +1);
    Print(src.sampleLocationGridSize, "VkExtent2D sampleLocationGridSize", os, indent +1);
    Print(src.sampleLocationsCount, "uint32_t sampleLocationsCount", os, indent +1);
            if( src.sampleLocationsCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to sampleLocationsCount" << std::endl;
            } else {
        PrintPointer(src.pSampleLocations, "const VkSampleLocationEXT * pSampleLocations", os, indent +1);
            }

}

template <>
inline void Print<VkSamplerBorderColorComponentMappingCreateInfoEXT>(VkSamplerBorderColorComponentMappingCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.components, "VkComponentMapping components", os, indent +1);
    Print(src.srgb, "VkBool32 srgb", os, indent +1);
}

template <>
inline void Print<VkSamplerCaptureDescriptorDataInfoEXT>(VkSamplerCaptureDescriptorDataInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.sampler, "VkSampler sampler", os, indent +1);
}

template <>
inline void Print<VkSamplerCreateInfo>(VkSamplerCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkSamplerCreateFlags flags", os, indent +1);
    Print(src.magFilter, "VkFilter magFilter", os, indent +1);
    Print(src.minFilter, "VkFilter minFilter", os, indent +1);
    Print(src.mipmapMode, "VkSamplerMipmapMode mipmapMode", os, indent +1);
    Print(src.addressModeU, "VkSamplerAddressMode addressModeU", os, indent +1);
    Print(src.addressModeV, "VkSamplerAddressMode addressModeV", os, indent +1);
    Print(src.addressModeW, "VkSamplerAddressMode addressModeW", os, indent +1);
    Print(src.mipLodBias, "float mipLodBias", os, indent +1);
    Print(src.anisotropyEnable, "VkBool32 anisotropyEnable", os, indent +1);
    Print(src.maxAnisotropy, "float maxAnisotropy", os, indent +1);
    Print(src.compareEnable, "VkBool32 compareEnable", os, indent +1);
    Print(src.compareOp, "VkCompareOp compareOp", os, indent +1);
    Print(src.minLod, "float minLod", os, indent +1);
    Print(src.maxLod, "float maxLod", os, indent +1);
    Print(src.borderColor, "VkBorderColor borderColor", os, indent +1);
    Print(src.unnormalizedCoordinates, "VkBool32 unnormalizedCoordinates", os, indent +1);
}

template <>
inline void Print<VkSamplerCustomBorderColorCreateInfoEXT>(VkSamplerCustomBorderColorCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        // handle union customBorderColor
    Print(src.format, "VkFormat format", os, indent +1);
}

template <>
inline void Print<VkSamplerReductionModeCreateInfo>(VkSamplerReductionModeCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.reductionMode, "VkSamplerReductionMode reductionMode", os, indent +1);
}

template <>
inline void Print<VkSamplerYcbcrConversionCreateInfo>(VkSamplerYcbcrConversionCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.format, "VkFormat format", os, indent +1);
    Print(src.ycbcrModel, "VkSamplerYcbcrModelConversion ycbcrModel", os, indent +1);
    Print(src.ycbcrRange, "VkSamplerYcbcrRange ycbcrRange", os, indent +1);
    Print(src.components, "VkComponentMapping components", os, indent +1);
    Print(src.xChromaOffset, "VkChromaLocation xChromaOffset", os, indent +1);
    Print(src.yChromaOffset, "VkChromaLocation yChromaOffset", os, indent +1);
    Print(src.chromaFilter, "VkFilter chromaFilter", os, indent +1);
    Print(src.forceExplicitReconstruction, "VkBool32 forceExplicitReconstruction", os, indent +1);
}

template <>
inline void Print<VkSamplerYcbcrConversionImageFormatProperties>(VkSamplerYcbcrConversionImageFormatProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.combinedImageSamplerDescriptorCount, "uint32_t combinedImageSamplerDescriptorCount", os, indent +1);
}

template <>
inline void Print<VkSamplerYcbcrConversionInfo>(VkSamplerYcbcrConversionInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.conversion, "VkSamplerYcbcrConversion conversion", os, indent +1);
}

template <>
inline void Print<VkSemaphoreCreateInfo>(VkSemaphoreCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkSemaphoreCreateFlags flags", os, indent +1);
}

template <>
inline void Print<VkSemaphoreGetFdInfoKHR>(VkSemaphoreGetFdInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.semaphore, "VkSemaphore semaphore", os, indent +1);
    Print(src.handleType, "VkExternalSemaphoreHandleTypeFlagBits handleType", os, indent +1);
}

template <>
inline void Print<VkSemaphoreSignalInfo>(VkSemaphoreSignalInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.semaphore, "VkSemaphore semaphore", os, indent +1);
    Print(src.value, "uint64_t value", os, indent +1);
}

template <>
inline void Print<VkSemaphoreSubmitInfo>(VkSemaphoreSubmitInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.semaphore, "VkSemaphore semaphore", os, indent +1);
    Print(src.value, "uint64_t value", os, indent +1);
    Print(src.stageMask, "VkPipelineStageFlags2 stageMask", os, indent +1);
    Print(src.deviceIndex, "uint32_t deviceIndex", os, indent +1);
}

template <>
inline void Print<VkSemaphoreTypeCreateInfo>(VkSemaphoreTypeCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.semaphoreType, "VkSemaphoreType semaphoreType", os, indent +1);
    Print(src.initialValue, "uint64_t initialValue", os, indent +1);
}

template <>
inline void Print<VkSemaphoreWaitInfo>(VkSemaphoreWaitInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkSemaphoreWaitFlags flags", os, indent +1);
    Print(src.semaphoreCount, "uint32_t semaphoreCount", os, indent +1);
            if( src.semaphoreCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to semaphoreCount" << std::endl;
            } else {
        PrintPointer(src.pSemaphores, "const VkSemaphore * pSemaphores", os, indent +1);
            }

            if( src.semaphoreCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to semaphoreCount" << std::endl;
            } else {
        PrintPointer(src.pValues, "const uint64_t * pValues", os, indent +1);
            }

}

template <>
inline void Print<VkSetStateFlagsIndirectCommandNV>(VkSetStateFlagsIndirectCommandNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.data, "uint32_t data", os, indent +1);
}

template <>
inline void Print<VkShaderModuleCreateInfo>(VkShaderModuleCreateInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkShaderModuleCreateFlags flags", os, indent +1);
    Print(src.codeSize, "size_t codeSize", os, indent +1);
            if( src.codeSize == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to codeSize" << std::endl;
            } else {
        PrintPointer(src.pCode, "const uint32_t * pCode", os, indent +1);
            }

}

template <>
inline void Print<VkShaderModuleIdentifierEXT>(VkShaderModuleIdentifierEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.identifierSize, "uint32_t identifierSize", os, indent +1);
    PrintArray(src.identifier, 0, "uint8_t [VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT] identifier", os, indent + 1);
}

template <>
inline void Print<VkShaderModuleValidationCacheCreateInfoEXT>(VkShaderModuleValidationCacheCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.validationCache, "VkValidationCacheEXT validationCache", os, indent +1);
}

template <>
inline void Print<VkShaderResourceUsageAMD>(VkShaderResourceUsageAMD const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.numUsedVgprs, "uint32_t numUsedVgprs", os, indent +1);
    Print(src.numUsedSgprs, "uint32_t numUsedSgprs", os, indent +1);
    Print(src.ldsSizePerLocalWorkGroup, "uint32_t ldsSizePerLocalWorkGroup", os, indent +1);
    Print(src.ldsUsageSizeInBytes, "size_t ldsUsageSizeInBytes", os, indent +1);
    Print(src.scratchMemUsageInBytes, "size_t scratchMemUsageInBytes", os, indent +1);
}

template <>
inline void Print<VkShaderStatisticsInfoAMD>(VkShaderStatisticsInfoAMD const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.shaderStageMask, "VkShaderStageFlags shaderStageMask", os, indent +1);
    Print(src.resourceUsage, "VkShaderResourceUsageAMD resourceUsage", os, indent +1);
    Print(src.numPhysicalVgprs, "uint32_t numPhysicalVgprs", os, indent +1);
    Print(src.numPhysicalSgprs, "uint32_t numPhysicalSgprs", os, indent +1);
    Print(src.numAvailableVgprs, "uint32_t numAvailableVgprs", os, indent +1);
    Print(src.numAvailableSgprs, "uint32_t numAvailableSgprs", os, indent +1);
    PrintArray(src.computeWorkGroupSize, 3, "uint32_t [3] computeWorkGroupSize", os, indent + 1);
}

template <>
inline void Print<VkShadingRatePaletteNV>(VkShadingRatePaletteNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.shadingRatePaletteEntryCount, "uint32_t shadingRatePaletteEntryCount", os, indent +1);
            if( src.shadingRatePaletteEntryCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to shadingRatePaletteEntryCount" << std::endl;
            } else {
        PrintPointer(src.pShadingRatePaletteEntries, "const VkShadingRatePaletteEntryNV * pShadingRatePaletteEntries", os, indent +1);
            }

}

template <>
inline void Print<VkSharedPresentSurfaceCapabilitiesKHR>(VkSharedPresentSurfaceCapabilitiesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.sharedPresentSupportedUsageFlags, "VkImageUsageFlags sharedPresentSupportedUsageFlags", os, indent +1);
}

template <>
inline void Print<VkSparseBufferMemoryBindInfo>(VkSparseBufferMemoryBindInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
        PrintInterfacePointer(src.buffer, "VkBuffer buffer", os, indent +1);
    Print(src.bindCount, "uint32_t bindCount", os, indent +1);
            if( src.bindCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to bindCount" << std::endl;
            } else {
        PrintPointer(src.pBinds, "const VkSparseMemoryBind * pBinds", os, indent +1);
            }

}

template <>
inline void Print<VkSparseImageFormatProperties>(VkSparseImageFormatProperties const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.aspectMask, "VkImageAspectFlags aspectMask", os, indent +1);
    Print(src.imageGranularity, "VkExtent3D imageGranularity", os, indent +1);
    Print(src.flags, "VkSparseImageFormatFlags flags", os, indent +1);
}

template <>
inline void Print<VkSparseImageFormatProperties2>(VkSparseImageFormatProperties2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.properties, "VkSparseImageFormatProperties properties", os, indent +1);
}

template <>
inline void Print<VkSparseImageMemoryBind>(VkSparseImageMemoryBind const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.subresource, "VkImageSubresource subresource", os, indent +1);
    Print(src.offset, "VkOffset3D offset", os, indent +1);
    Print(src.extent, "VkExtent3D extent", os, indent +1);
        PrintInterfacePointer(src.memory, "VkDeviceMemory memory", os, indent +1);
    Print(src.memoryOffset, "VkDeviceSize memoryOffset", os, indent +1);
    Print(src.flags, "VkSparseMemoryBindFlags flags", os, indent +1);
}

template <>
inline void Print<VkSparseImageMemoryBindInfo>(VkSparseImageMemoryBindInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
        PrintInterfacePointer(src.image, "VkImage image", os, indent +1);
    Print(src.bindCount, "uint32_t bindCount", os, indent +1);
            if( src.bindCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to bindCount" << std::endl;
            } else {
        PrintPointer(src.pBinds, "const VkSparseImageMemoryBind * pBinds", os, indent +1);
            }

}

template <>
inline void Print<VkSparseImageMemoryRequirements>(VkSparseImageMemoryRequirements const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.formatProperties, "VkSparseImageFormatProperties formatProperties", os, indent +1);
    Print(src.imageMipTailFirstLod, "uint32_t imageMipTailFirstLod", os, indent +1);
    Print(src.imageMipTailSize, "VkDeviceSize imageMipTailSize", os, indent +1);
    Print(src.imageMipTailOffset, "VkDeviceSize imageMipTailOffset", os, indent +1);
    Print(src.imageMipTailStride, "VkDeviceSize imageMipTailStride", os, indent +1);
}

template <>
inline void Print<VkSparseImageMemoryRequirements2>(VkSparseImageMemoryRequirements2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.memoryRequirements, "VkSparseImageMemoryRequirements memoryRequirements", os, indent +1);
}

template <>
inline void Print<VkSparseImageOpaqueMemoryBindInfo>(VkSparseImageOpaqueMemoryBindInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
        PrintInterfacePointer(src.image, "VkImage image", os, indent +1);
    Print(src.bindCount, "uint32_t bindCount", os, indent +1);
            if( src.bindCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to bindCount" << std::endl;
            } else {
        PrintPointer(src.pBinds, "const VkSparseMemoryBind * pBinds", os, indent +1);
            }

}

template <>
inline void Print<VkSparseMemoryBind>(VkSparseMemoryBind const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.resourceOffset, "VkDeviceSize resourceOffset", os, indent +1);
    Print(src.size, "VkDeviceSize size", os, indent +1);
        PrintInterfacePointer(src.memory, "VkDeviceMemory memory", os, indent +1);
    Print(src.memoryOffset, "VkDeviceSize memoryOffset", os, indent +1);
    Print(src.flags, "VkSparseMemoryBindFlags flags", os, indent +1);
}

template <>
inline void Print<VkSpecializationInfo>(VkSpecializationInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.mapEntryCount, "uint32_t mapEntryCount", os, indent +1);
            if( src.mapEntryCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to mapEntryCount" << std::endl;
            } else {
        PrintPointer(src.pMapEntries, "const VkSpecializationMapEntry * pMapEntries", os, indent +1);
            }

    Print(src.dataSize, "size_t dataSize", os, indent +1);
            if( src.dataSize == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to dataSize" << std::endl;
            } else {
        PrintPointer(src.pData, "const void * pData", os, indent +1);
            }

}

template <>
inline void Print<VkSpecializationMapEntry>(VkSpecializationMapEntry const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.constantID, "uint32_t constantID", os, indent +1);
    Print(src.offset, "uint32_t offset", os, indent +1);
    Print(src.size, "size_t size", os, indent +1);
}

template <>
inline void Print<VkStencilOpState>(VkStencilOpState const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.failOp, "VkStencilOp failOp", os, indent +1);
    Print(src.passOp, "VkStencilOp passOp", os, indent +1);
    Print(src.depthFailOp, "VkStencilOp depthFailOp", os, indent +1);
    Print(src.compareOp, "VkCompareOp compareOp", os, indent +1);
    Print(src.compareMask, "uint32_t compareMask", os, indent +1);
    Print(src.writeMask, "uint32_t writeMask", os, indent +1);
    Print(src.reference, "uint32_t reference", os, indent +1);
}

template <>
inline void Print<VkStridedDeviceAddressRegionKHR>(VkStridedDeviceAddressRegionKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.deviceAddress, "VkDeviceAddress deviceAddress", os, indent +1);
    Print(src.stride, "VkDeviceSize stride", os, indent +1);
    Print(src.size, "VkDeviceSize size", os, indent +1);
}

template <>
inline void Print<VkSubmitInfo>(VkSubmitInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.waitSemaphoreCount, "uint32_t waitSemaphoreCount", os, indent +1);
            if( src.waitSemaphoreCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to waitSemaphoreCount" << std::endl;
            } else {
        PrintPointer(src.pWaitSemaphores, "const VkSemaphore * pWaitSemaphores", os, indent +1);
            }

            if( src.waitSemaphoreCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to waitSemaphoreCount" << std::endl;
            } else {
        PrintPointer(src.pWaitDstStageMask, "const VkPipelineStageFlags * pWaitDstStageMask", os, indent +1);
            }

    Print(src.commandBufferCount, "uint32_t commandBufferCount", os, indent +1);
            if( src.commandBufferCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to commandBufferCount" << std::endl;
            } else {
        PrintPointer(src.pCommandBuffers, "const VkCommandBuffer * pCommandBuffers", os, indent +1);
            }

    Print(src.signalSemaphoreCount, "uint32_t signalSemaphoreCount", os, indent +1);
            if( src.signalSemaphoreCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to signalSemaphoreCount" << std::endl;
            } else {
        PrintPointer(src.pSignalSemaphores, "const VkSemaphore * pSignalSemaphores", os, indent +1);
            }

}

template <>
inline void Print<VkSubmitInfo2>(VkSubmitInfo2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkSubmitFlags flags", os, indent +1);
    Print(src.waitSemaphoreInfoCount, "uint32_t waitSemaphoreInfoCount", os, indent +1);
            if( src.waitSemaphoreInfoCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to waitSemaphoreInfoCount" << std::endl;
            } else {
        PrintPointer(src.pWaitSemaphoreInfos, "const VkSemaphoreSubmitInfo * pWaitSemaphoreInfos", os, indent +1);
            }

    Print(src.commandBufferInfoCount, "uint32_t commandBufferInfoCount", os, indent +1);
            if( src.commandBufferInfoCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to commandBufferInfoCount" << std::endl;
            } else {
        PrintPointer(src.pCommandBufferInfos, "const VkCommandBufferSubmitInfo * pCommandBufferInfos", os, indent +1);
            }

    Print(src.signalSemaphoreInfoCount, "uint32_t signalSemaphoreInfoCount", os, indent +1);
            if( src.signalSemaphoreInfoCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to signalSemaphoreInfoCount" << std::endl;
            } else {
        PrintPointer(src.pSignalSemaphoreInfos, "const VkSemaphoreSubmitInfo * pSignalSemaphoreInfos", os, indent +1);
            }

}

template <>
inline void Print<VkSubpassBeginInfo>(VkSubpassBeginInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.contents, "VkSubpassContents contents", os, indent +1);
}

template <>
inline void Print<VkSubpassDependency>(VkSubpassDependency const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.srcSubpass, "uint32_t srcSubpass", os, indent +1);
    Print(src.dstSubpass, "uint32_t dstSubpass", os, indent +1);
    Print(src.srcStageMask, "VkPipelineStageFlags srcStageMask", os, indent +1);
    Print(src.dstStageMask, "VkPipelineStageFlags dstStageMask", os, indent +1);
    Print(src.srcAccessMask, "VkAccessFlags srcAccessMask", os, indent +1);
    Print(src.dstAccessMask, "VkAccessFlags dstAccessMask", os, indent +1);
    Print(src.dependencyFlags, "VkDependencyFlags dependencyFlags", os, indent +1);
}

template <>
inline void Print<VkSubpassDependency2>(VkSubpassDependency2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.srcSubpass, "uint32_t srcSubpass", os, indent +1);
    Print(src.dstSubpass, "uint32_t dstSubpass", os, indent +1);
    Print(src.srcStageMask, "VkPipelineStageFlags srcStageMask", os, indent +1);
    Print(src.dstStageMask, "VkPipelineStageFlags dstStageMask", os, indent +1);
    Print(src.srcAccessMask, "VkAccessFlags srcAccessMask", os, indent +1);
    Print(src.dstAccessMask, "VkAccessFlags dstAccessMask", os, indent +1);
    Print(src.dependencyFlags, "VkDependencyFlags dependencyFlags", os, indent +1);
    Print(src.viewOffset, "int32_t viewOffset", os, indent +1);
}

template <>
inline void Print<VkSubpassDescription>(VkSubpassDescription const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.flags, "VkSubpassDescriptionFlags flags", os, indent +1);
    Print(src.pipelineBindPoint, "VkPipelineBindPoint pipelineBindPoint", os, indent +1);
    Print(src.inputAttachmentCount, "uint32_t inputAttachmentCount", os, indent +1);
            if( src.inputAttachmentCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to inputAttachmentCount" << std::endl;
            } else {
        PrintPointer(src.pInputAttachments, "const VkAttachmentReference * pInputAttachments", os, indent +1);
            }

    Print(src.colorAttachmentCount, "uint32_t colorAttachmentCount", os, indent +1);
            if( src.colorAttachmentCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to colorAttachmentCount" << std::endl;
            } else {
        PrintPointer(src.pColorAttachments, "const VkAttachmentReference * pColorAttachments", os, indent +1);
            }

            if( src.colorAttachmentCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to colorAttachmentCount" << std::endl;
            } else {
        PrintPointer(src.pResolveAttachments, "const VkAttachmentReference * pResolveAttachments", os, indent +1);
            }

        PrintPointer(src.pDepthStencilAttachment, "const VkAttachmentReference * pDepthStencilAttachment", os, indent +1);
    Print(src.preserveAttachmentCount, "uint32_t preserveAttachmentCount", os, indent +1);
            if( src.preserveAttachmentCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to preserveAttachmentCount" << std::endl;
            } else {
        PrintPointer(src.pPreserveAttachments, "const uint32_t * pPreserveAttachments", os, indent +1);
            }

}

template <>
inline void Print<VkSubpassDescription2>(VkSubpassDescription2 const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkSubpassDescriptionFlags flags", os, indent +1);
    Print(src.pipelineBindPoint, "VkPipelineBindPoint pipelineBindPoint", os, indent +1);
    Print(src.viewMask, "uint32_t viewMask", os, indent +1);
    Print(src.inputAttachmentCount, "uint32_t inputAttachmentCount", os, indent +1);
            if( src.inputAttachmentCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to inputAttachmentCount" << std::endl;
            } else {
        PrintPointer(src.pInputAttachments, "const VkAttachmentReference2 * pInputAttachments", os, indent +1);
            }

    Print(src.colorAttachmentCount, "uint32_t colorAttachmentCount", os, indent +1);
            if( src.colorAttachmentCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to colorAttachmentCount" << std::endl;
            } else {
        PrintPointer(src.pColorAttachments, "const VkAttachmentReference2 * pColorAttachments", os, indent +1);
            }

            if( src.colorAttachmentCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to colorAttachmentCount" << std::endl;
            } else {
        PrintPointer(src.pResolveAttachments, "const VkAttachmentReference2 * pResolveAttachments", os, indent +1);
            }

        PrintPointer(src.pDepthStencilAttachment, "const VkAttachmentReference2 * pDepthStencilAttachment", os, indent +1);
    Print(src.preserveAttachmentCount, "uint32_t preserveAttachmentCount", os, indent +1);
            if( src.preserveAttachmentCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to preserveAttachmentCount" << std::endl;
            } else {
        PrintPointer(src.pPreserveAttachments, "const uint32_t * pPreserveAttachments", os, indent +1);
            }

}

template <>
inline void Print<VkSubpassDescriptionDepthStencilResolve>(VkSubpassDescriptionDepthStencilResolve const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.depthResolveMode, "VkResolveModeFlagBits depthResolveMode", os, indent +1);
    Print(src.stencilResolveMode, "VkResolveModeFlagBits stencilResolveMode", os, indent +1);
        PrintPointer(src.pDepthStencilResolveAttachment, "const VkAttachmentReference2 * pDepthStencilResolveAttachment", os, indent +1);
}

template <>
inline void Print<VkSubpassEndInfo>(VkSubpassEndInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
}

template <>
inline void Print<VkSubpassFragmentDensityMapOffsetEndInfoQCOM>(VkSubpassFragmentDensityMapOffsetEndInfoQCOM const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.fragmentDensityOffsetCount, "uint32_t fragmentDensityOffsetCount", os, indent +1);
            if( src.fragmentDensityOffsetCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to fragmentDensityOffsetCount" << std::endl;
            } else {
        PrintPointer(src.pFragmentDensityOffsets, "const VkOffset2D * pFragmentDensityOffsets", os, indent +1);
            }

}

template <>
inline void Print<VkSubpassResolvePerformanceQueryEXT>(VkSubpassResolvePerformanceQueryEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.optimal, "VkBool32 optimal", os, indent +1);
}

template <>
inline void Print<VkSubpassSampleLocationsEXT>(VkSubpassSampleLocationsEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.subpassIndex, "uint32_t subpassIndex", os, indent +1);
    Print(src.sampleLocationsInfo, "VkSampleLocationsInfoEXT sampleLocationsInfo", os, indent +1);
}

template <>
inline void Print<VkSubpassShadingPipelineCreateInfoHUAWEI>(VkSubpassShadingPipelineCreateInfoHUAWEI const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
        PrintInterfacePointer(src.renderPass, "VkRenderPass renderPass", os, indent +1);
    Print(src.subpass, "uint32_t subpass", os, indent +1);
}

template <>
inline void Print<VkSubresourceLayout>(VkSubresourceLayout const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.offset, "VkDeviceSize offset", os, indent +1);
    Print(src.size, "VkDeviceSize size", os, indent +1);
    Print(src.rowPitch, "VkDeviceSize rowPitch", os, indent +1);
    Print(src.arrayPitch, "VkDeviceSize arrayPitch", os, indent +1);
    Print(src.depthPitch, "VkDeviceSize depthPitch", os, indent +1);
}

template <>
inline void Print<VkSubresourceLayout2EXT>(VkSubresourceLayout2EXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.subresourceLayout, "VkSubresourceLayout subresourceLayout", os, indent +1);
}

template <>
inline void Print<VkSurfaceCapabilities2EXT>(VkSurfaceCapabilities2EXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.minImageCount, "uint32_t minImageCount", os, indent +1);
    Print(src.maxImageCount, "uint32_t maxImageCount", os, indent +1);
    Print(src.currentExtent, "VkExtent2D currentExtent", os, indent +1);
    Print(src.minImageExtent, "VkExtent2D minImageExtent", os, indent +1);
    Print(src.maxImageExtent, "VkExtent2D maxImageExtent", os, indent +1);
    Print(src.maxImageArrayLayers, "uint32_t maxImageArrayLayers", os, indent +1);
    Print(src.supportedTransforms, "VkSurfaceTransformFlagsKHR supportedTransforms", os, indent +1);
    Print(src.currentTransform, "VkSurfaceTransformFlagBitsKHR currentTransform", os, indent +1);
    Print(src.supportedCompositeAlpha, "VkCompositeAlphaFlagsKHR supportedCompositeAlpha", os, indent +1);
    Print(src.supportedUsageFlags, "VkImageUsageFlags supportedUsageFlags", os, indent +1);
    Print(src.supportedSurfaceCounters, "VkSurfaceCounterFlagsEXT supportedSurfaceCounters", os, indent +1);
}

template <>
inline void Print<VkSurfaceCapabilities2KHR>(VkSurfaceCapabilities2KHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.surfaceCapabilities, "VkSurfaceCapabilitiesKHR surfaceCapabilities", os, indent +1);
}

template <>
inline void Print<VkSurfaceCapabilitiesKHR>(VkSurfaceCapabilitiesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.minImageCount, "uint32_t minImageCount", os, indent +1);
    Print(src.maxImageCount, "uint32_t maxImageCount", os, indent +1);
    Print(src.currentExtent, "VkExtent2D currentExtent", os, indent +1);
    Print(src.minImageExtent, "VkExtent2D minImageExtent", os, indent +1);
    Print(src.maxImageExtent, "VkExtent2D maxImageExtent", os, indent +1);
    Print(src.maxImageArrayLayers, "uint32_t maxImageArrayLayers", os, indent +1);
    Print(src.supportedTransforms, "VkSurfaceTransformFlagsKHR supportedTransforms", os, indent +1);
    Print(src.currentTransform, "VkSurfaceTransformFlagBitsKHR currentTransform", os, indent +1);
    Print(src.supportedCompositeAlpha, "VkCompositeAlphaFlagsKHR supportedCompositeAlpha", os, indent +1);
    Print(src.supportedUsageFlags, "VkImageUsageFlags supportedUsageFlags", os, indent +1);
}

template <>
inline void Print<VkSurfaceCapabilitiesPresentBarrierNV>(VkSurfaceCapabilitiesPresentBarrierNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.presentBarrierSupported, "VkBool32 presentBarrierSupported", os, indent +1);
}

template <>
inline void Print<VkSurfaceFormat2KHR>(VkSurfaceFormat2KHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.surfaceFormat, "VkSurfaceFormatKHR surfaceFormat", os, indent +1);
}

template <>
inline void Print<VkSurfaceFormatKHR>(VkSurfaceFormatKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.format, "VkFormat format", os, indent +1);
    Print(src.colorSpace, "VkColorSpaceKHR colorSpace", os, indent +1);
}

template <>
inline void Print<VkSurfacePresentModeCompatibilityEXT>(VkSurfacePresentModeCompatibilityEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.presentModeCount, "uint32_t presentModeCount", os, indent +1);
            if( src.presentModeCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to presentModeCount" << std::endl;
            } else {
        PrintPointer(src.pPresentModes, "VkPresentModeKHR * pPresentModes", os, indent +1);
            }

}

template <>
inline void Print<VkSurfacePresentModeEXT>(VkSurfacePresentModeEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.presentMode, "VkPresentModeKHR presentMode", os, indent +1);
}

template <>
inline void Print<VkSurfacePresentScalingCapabilitiesEXT>(VkSurfacePresentScalingCapabilitiesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.supportedPresentScaling, "VkPresentScalingFlagsEXT supportedPresentScaling", os, indent +1);
    Print(src.supportedPresentGravityX, "VkPresentGravityFlagsEXT supportedPresentGravityX", os, indent +1);
    Print(src.supportedPresentGravityY, "VkPresentGravityFlagsEXT supportedPresentGravityY", os, indent +1);
    Print(src.minScaledImageExtent, "VkExtent2D minScaledImageExtent", os, indent +1);
    Print(src.maxScaledImageExtent, "VkExtent2D maxScaledImageExtent", os, indent +1);
}

template <>
inline void Print<VkSurfaceProtectedCapabilitiesKHR>(VkSurfaceProtectedCapabilitiesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.supportsProtected, "VkBool32 supportsProtected", os, indent +1);
}

template <>
inline void Print<VkSwapchainCounterCreateInfoEXT>(VkSwapchainCounterCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.surfaceCounters, "VkSurfaceCounterFlagsEXT surfaceCounters", os, indent +1);
}

template <>
inline void Print<VkSwapchainCreateInfoKHR>(VkSwapchainCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkSwapchainCreateFlagsKHR flags", os, indent +1);
        PrintInterfacePointer(src.surface, "VkSurfaceKHR surface", os, indent +1);
    Print(src.minImageCount, "uint32_t minImageCount", os, indent +1);
    Print(src.imageFormat, "VkFormat imageFormat", os, indent +1);
    Print(src.imageColorSpace, "VkColorSpaceKHR imageColorSpace", os, indent +1);
    Print(src.imageExtent, "VkExtent2D imageExtent", os, indent +1);
    Print(src.imageArrayLayers, "uint32_t imageArrayLayers", os, indent +1);
    Print(src.imageUsage, "VkImageUsageFlags imageUsage", os, indent +1);
    Print(src.imageSharingMode, "VkSharingMode imageSharingMode", os, indent +1);
    Print(src.queueFamilyIndexCount, "uint32_t queueFamilyIndexCount", os, indent +1);
            if( src.queueFamilyIndexCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to queueFamilyIndexCount" << std::endl;
            } else {
        PrintPointer(src.pQueueFamilyIndices, "const uint32_t * pQueueFamilyIndices", os, indent +1);
            }

    Print(src.preTransform, "VkSurfaceTransformFlagBitsKHR preTransform", os, indent +1);
    Print(src.compositeAlpha, "VkCompositeAlphaFlagBitsKHR compositeAlpha", os, indent +1);
    Print(src.presentMode, "VkPresentModeKHR presentMode", os, indent +1);
    Print(src.clipped, "VkBool32 clipped", os, indent +1);
        PrintInterfacePointer(src.oldSwapchain, "VkSwapchainKHR oldSwapchain", os, indent +1);
}

template <>
inline void Print<VkSwapchainDisplayNativeHdrCreateInfoAMD>(VkSwapchainDisplayNativeHdrCreateInfoAMD const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.localDimmingEnable, "VkBool32 localDimmingEnable", os, indent +1);
}

template <>
inline void Print<VkSwapchainPresentBarrierCreateInfoNV>(VkSwapchainPresentBarrierCreateInfoNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.presentBarrierEnable, "VkBool32 presentBarrierEnable", os, indent +1);
}

template <>
inline void Print<VkSwapchainPresentFenceInfoEXT>(VkSwapchainPresentFenceInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.swapchainCount, "uint32_t swapchainCount", os, indent +1);
            if( src.swapchainCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to swapchainCount" << std::endl;
            } else {
        PrintPointer(src.pFences, "const VkFence * pFences", os, indent +1);
            }

}

template <>
inline void Print<VkSwapchainPresentModeInfoEXT>(VkSwapchainPresentModeInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.swapchainCount, "uint32_t swapchainCount", os, indent +1);
            if( src.swapchainCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to swapchainCount" << std::endl;
            } else {
        PrintPointer(src.pPresentModes, "const VkPresentModeKHR * pPresentModes", os, indent +1);
            }

}

template <>
inline void Print<VkSwapchainPresentModesCreateInfoEXT>(VkSwapchainPresentModesCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.presentModeCount, "uint32_t presentModeCount", os, indent +1);
            if( src.presentModeCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to presentModeCount" << std::endl;
            } else {
        PrintPointer(src.pPresentModes, "const VkPresentModeKHR * pPresentModes", os, indent +1);
            }

}

template <>
inline void Print<VkSwapchainPresentScalingCreateInfoEXT>(VkSwapchainPresentScalingCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.scalingBehavior, "VkPresentScalingFlagsEXT scalingBehavior", os, indent +1);
    Print(src.presentGravityX, "VkPresentGravityFlagsEXT presentGravityX", os, indent +1);
    Print(src.presentGravityY, "VkPresentGravityFlagsEXT presentGravityY", os, indent +1);
}

template <>
inline void Print<VkTextureLODGatherFormatPropertiesAMD>(VkTextureLODGatherFormatPropertiesAMD const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.supportsTextureGatherLODBiasAMD, "VkBool32 supportsTextureGatherLODBiasAMD", os, indent +1);
}

template <>
inline void Print<VkTilePropertiesQCOM>(VkTilePropertiesQCOM const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.tileSize, "VkExtent3D tileSize", os, indent +1);
    Print(src.apronSize, "VkExtent2D apronSize", os, indent +1);
    Print(src.origin, "VkOffset2D origin", os, indent +1);
}

template <>
inline void Print<VkTimelineSemaphoreSubmitInfo>(VkTimelineSemaphoreSubmitInfo const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.waitSemaphoreValueCount, "uint32_t waitSemaphoreValueCount", os, indent +1);
            if( src.waitSemaphoreValueCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to waitSemaphoreValueCount" << std::endl;
            } else {
        PrintPointer(src.pWaitSemaphoreValues, "const uint64_t * pWaitSemaphoreValues", os, indent +1);
            }

    Print(src.signalSemaphoreValueCount, "uint32_t signalSemaphoreValueCount", os, indent +1);
            if( src.signalSemaphoreValueCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to signalSemaphoreValueCount" << std::endl;
            } else {
        PrintPointer(src.pSignalSemaphoreValues, "const uint64_t * pSignalSemaphoreValues", os, indent +1);
            }

}

template <>
inline void Print<VkTraceRaysIndirectCommand2KHR>(VkTraceRaysIndirectCommand2KHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.raygenShaderRecordAddress, "VkDeviceAddress raygenShaderRecordAddress", os, indent +1);
    Print(src.raygenShaderRecordSize, "VkDeviceSize raygenShaderRecordSize", os, indent +1);
    Print(src.missShaderBindingTableAddress, "VkDeviceAddress missShaderBindingTableAddress", os, indent +1);
    Print(src.missShaderBindingTableSize, "VkDeviceSize missShaderBindingTableSize", os, indent +1);
    Print(src.missShaderBindingTableStride, "VkDeviceSize missShaderBindingTableStride", os, indent +1);
    Print(src.hitShaderBindingTableAddress, "VkDeviceAddress hitShaderBindingTableAddress", os, indent +1);
    Print(src.hitShaderBindingTableSize, "VkDeviceSize hitShaderBindingTableSize", os, indent +1);
    Print(src.hitShaderBindingTableStride, "VkDeviceSize hitShaderBindingTableStride", os, indent +1);
    Print(src.callableShaderBindingTableAddress, "VkDeviceAddress callableShaderBindingTableAddress", os, indent +1);
    Print(src.callableShaderBindingTableSize, "VkDeviceSize callableShaderBindingTableSize", os, indent +1);
    Print(src.callableShaderBindingTableStride, "VkDeviceSize callableShaderBindingTableStride", os, indent +1);
    Print(src.width, "uint32_t width", os, indent +1);
    Print(src.height, "uint32_t height", os, indent +1);
    Print(src.depth, "uint32_t depth", os, indent +1);
}

template <>
inline void Print<VkTraceRaysIndirectCommandKHR>(VkTraceRaysIndirectCommandKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.width, "uint32_t width", os, indent +1);
    Print(src.height, "uint32_t height", os, indent +1);
    Print(src.depth, "uint32_t depth", os, indent +1);
}

template <>
inline void Print<VkTransformMatrixKHR>(VkTransformMatrixKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    PrintArray(src.matrix, 3, "float [3][4] matrix", os, indent + 1);
}

template <>
inline void Print<VkValidationCacheCreateInfoEXT>(VkValidationCacheCreateInfoEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkValidationCacheCreateFlagsEXT flags", os, indent +1);
    Print(src.initialDataSize, "size_t initialDataSize", os, indent +1);
            if( src.initialDataSize == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to initialDataSize" << std::endl;
            } else {
        PrintPointer(src.pInitialData, "const void * pInitialData", os, indent +1);
            }

}

template <>
inline void Print<VkValidationFeaturesEXT>(VkValidationFeaturesEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.enabledValidationFeatureCount, "uint32_t enabledValidationFeatureCount", os, indent +1);
            if( src.enabledValidationFeatureCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to enabledValidationFeatureCount" << std::endl;
            } else {
        PrintPointer(src.pEnabledValidationFeatures, "const VkValidationFeatureEnableEXT * pEnabledValidationFeatures", os, indent +1);
            }

    Print(src.disabledValidationFeatureCount, "uint32_t disabledValidationFeatureCount", os, indent +1);
            if( src.disabledValidationFeatureCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to disabledValidationFeatureCount" << std::endl;
            } else {
        PrintPointer(src.pDisabledValidationFeatures, "const VkValidationFeatureDisableEXT * pDisabledValidationFeatures", os, indent +1);
            }

}

template <>
inline void Print<VkValidationFlagsEXT>(VkValidationFlagsEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.disabledValidationCheckCount, "uint32_t disabledValidationCheckCount", os, indent +1);
            if( src.disabledValidationCheckCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to disabledValidationCheckCount" << std::endl;
            } else {
        PrintPointer(src.pDisabledValidationChecks, "const VkValidationCheckEXT * pDisabledValidationChecks", os, indent +1);
            }

}

template <>
inline void Print<VkVertexInputAttributeDescription>(VkVertexInputAttributeDescription const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.location, "uint32_t location", os, indent +1);
    Print(src.binding, "uint32_t binding", os, indent +1);
    Print(src.format, "VkFormat format", os, indent +1);
    Print(src.offset, "uint32_t offset", os, indent +1);
}

template <>
inline void Print<VkVertexInputAttributeDescription2EXT>(VkVertexInputAttributeDescription2EXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.location, "uint32_t location", os, indent +1);
    Print(src.binding, "uint32_t binding", os, indent +1);
    Print(src.format, "VkFormat format", os, indent +1);
    Print(src.offset, "uint32_t offset", os, indent +1);
}

template <>
inline void Print<VkVertexInputBindingDescription>(VkVertexInputBindingDescription const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.binding, "uint32_t binding", os, indent +1);
    Print(src.stride, "uint32_t stride", os, indent +1);
    Print(src.inputRate, "VkVertexInputRate inputRate", os, indent +1);
}

template <>
inline void Print<VkVertexInputBindingDescription2EXT>(VkVertexInputBindingDescription2EXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.binding, "uint32_t binding", os, indent +1);
    Print(src.stride, "uint32_t stride", os, indent +1);
    Print(src.inputRate, "VkVertexInputRate inputRate", os, indent +1);
    Print(src.divisor, "uint32_t divisor", os, indent +1);
}

template <>
inline void Print<VkVertexInputBindingDivisorDescriptionEXT>(VkVertexInputBindingDivisorDescriptionEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.binding, "uint32_t binding", os, indent +1);
    Print(src.divisor, "uint32_t divisor", os, indent +1);
}

template <>
inline void Print<VkVideoBeginCodingInfoKHR>(VkVideoBeginCodingInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkVideoBeginCodingFlagsKHR flags", os, indent +1);
        PrintInterfacePointer(src.videoSession, "VkVideoSessionKHR videoSession", os, indent +1);
        PrintInterfacePointer(src.videoSessionParameters, "VkVideoSessionParametersKHR videoSessionParameters", os, indent +1);
    Print(src.referenceSlotCount, "uint32_t referenceSlotCount", os, indent +1);
            if( src.referenceSlotCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to referenceSlotCount" << std::endl;
            } else {
        PrintPointer(src.pReferenceSlots, "const VkVideoReferenceSlotInfoKHR * pReferenceSlots", os, indent +1);
            }

}

template <>
inline void Print<VkVideoCapabilitiesKHR>(VkVideoCapabilitiesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.flags, "VkVideoCapabilityFlagsKHR flags", os, indent +1);
    Print(src.minBitstreamBufferOffsetAlignment, "VkDeviceSize minBitstreamBufferOffsetAlignment", os, indent +1);
    Print(src.minBitstreamBufferSizeAlignment, "VkDeviceSize minBitstreamBufferSizeAlignment", os, indent +1);
    Print(src.pictureAccessGranularity, "VkExtent2D pictureAccessGranularity", os, indent +1);
    Print(src.minCodedExtent, "VkExtent2D minCodedExtent", os, indent +1);
    Print(src.maxCodedExtent, "VkExtent2D maxCodedExtent", os, indent +1);
    Print(src.maxDpbSlots, "uint32_t maxDpbSlots", os, indent +1);
    Print(src.maxActiveReferencePictures, "uint32_t maxActiveReferencePictures", os, indent +1);
    Print(src.stdHeaderVersion, "VkExtensionProperties stdHeaderVersion", os, indent +1);
}

template <>
inline void Print<VkVideoCodingControlInfoKHR>(VkVideoCodingControlInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkVideoCodingControlFlagsKHR flags", os, indent +1);
}

template <>
inline void Print<VkVideoDecodeCapabilitiesKHR>(VkVideoDecodeCapabilitiesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.flags, "VkVideoDecodeCapabilityFlagsKHR flags", os, indent +1);
}

template <>
inline void Print<VkVideoDecodeInfoKHR>(VkVideoDecodeInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkVideoDecodeFlagsKHR flags", os, indent +1);
        PrintInterfacePointer(src.srcBuffer, "VkBuffer srcBuffer", os, indent +1);
    Print(src.srcBufferOffset, "VkDeviceSize srcBufferOffset", os, indent +1);
    Print(src.srcBufferRange, "VkDeviceSize srcBufferRange", os, indent +1);
    Print(src.dstPictureResource, "VkVideoPictureResourceInfoKHR dstPictureResource", os, indent +1);
        PrintPointer(src.pSetupReferenceSlot, "const VkVideoReferenceSlotInfoKHR * pSetupReferenceSlot", os, indent +1);
    Print(src.referenceSlotCount, "uint32_t referenceSlotCount", os, indent +1);
            if( src.referenceSlotCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to referenceSlotCount" << std::endl;
            } else {
        PrintPointer(src.pReferenceSlots, "const VkVideoReferenceSlotInfoKHR * pReferenceSlots", os, indent +1);
            }

}

template <>
inline void Print<VkVideoDecodeUsageInfoKHR>(VkVideoDecodeUsageInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.videoUsageHints, "VkVideoDecodeUsageFlagsKHR videoUsageHints", os, indent +1);
}

template <>
inline void Print<VkVideoEncodeCapabilitiesKHR>(VkVideoEncodeCapabilitiesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.flags, "VkVideoEncodeCapabilityFlagsKHR flags", os, indent +1);
    Print(src.rateControlModes, "VkVideoEncodeRateControlModeFlagsKHR rateControlModes", os, indent +1);
    Print(src.rateControlLayerCount, "uint8_t rateControlLayerCount", os, indent +1);
    Print(src.qualityLevelCount, "uint8_t qualityLevelCount", os, indent +1);
    Print(src.inputImageDataFillAlignment, "VkExtent2D inputImageDataFillAlignment", os, indent +1);
}

template <>
inline void Print<VkVideoEncodeInfoKHR>(VkVideoEncodeInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkVideoEncodeFlagsKHR flags", os, indent +1);
    Print(src.qualityLevel, "uint32_t qualityLevel", os, indent +1);
        PrintInterfacePointer(src.dstBitstreamBuffer, "VkBuffer dstBitstreamBuffer", os, indent +1);
    Print(src.dstBitstreamBufferOffset, "VkDeviceSize dstBitstreamBufferOffset", os, indent +1);
    Print(src.dstBitstreamBufferMaxRange, "VkDeviceSize dstBitstreamBufferMaxRange", os, indent +1);
    Print(src.srcPictureResource, "VkVideoPictureResourceInfoKHR srcPictureResource", os, indent +1);
        PrintPointer(src.pSetupReferenceSlot, "const VkVideoReferenceSlotInfoKHR * pSetupReferenceSlot", os, indent +1);
    Print(src.referenceSlotCount, "uint32_t referenceSlotCount", os, indent +1);
            if( src.referenceSlotCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to referenceSlotCount" << std::endl;
            } else {
        PrintPointer(src.pReferenceSlots, "const VkVideoReferenceSlotInfoKHR * pReferenceSlots", os, indent +1);
            }

    Print(src.precedingExternallyEncodedBytes, "uint32_t precedingExternallyEncodedBytes", os, indent +1);
}

template <>
inline void Print<VkVideoEncodeRateControlInfoKHR>(VkVideoEncodeRateControlInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkVideoEncodeRateControlFlagsKHR flags", os, indent +1);
    Print(src.rateControlMode, "VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode", os, indent +1);
    Print(src.layerCount, "uint8_t layerCount", os, indent +1);
            if( src.layerCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to layerCount" << std::endl;
            } else {
        PrintPointer(src.pLayerConfigs, "const VkVideoEncodeRateControlLayerInfoKHR * pLayerConfigs", os, indent +1);
            }

}

template <>
inline void Print<VkVideoEncodeRateControlLayerInfoKHR>(VkVideoEncodeRateControlLayerInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.averageBitrate, "uint32_t averageBitrate", os, indent +1);
    Print(src.maxBitrate, "uint32_t maxBitrate", os, indent +1);
    Print(src.frameRateNumerator, "uint32_t frameRateNumerator", os, indent +1);
    Print(src.frameRateDenominator, "uint32_t frameRateDenominator", os, indent +1);
    Print(src.virtualBufferSizeInMs, "uint32_t virtualBufferSizeInMs", os, indent +1);
    Print(src.initialVirtualBufferSizeInMs, "uint32_t initialVirtualBufferSizeInMs", os, indent +1);
}

template <>
inline void Print<VkVideoEncodeUsageInfoKHR>(VkVideoEncodeUsageInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.videoUsageHints, "VkVideoEncodeUsageFlagsKHR videoUsageHints", os, indent +1);
    Print(src.videoContentHints, "VkVideoEncodeContentFlagsKHR videoContentHints", os, indent +1);
    Print(src.tuningMode, "VkVideoEncodeTuningModeKHR tuningMode", os, indent +1);
}

template <>
inline void Print<VkVideoEndCodingInfoKHR>(VkVideoEndCodingInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkVideoEndCodingFlagsKHR flags", os, indent +1);
}

template <>
inline void Print<VkVideoFormatPropertiesKHR>(VkVideoFormatPropertiesKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.format, "VkFormat format", os, indent +1);
    Print(src.componentMapping, "VkComponentMapping componentMapping", os, indent +1);
    Print(src.imageCreateFlags, "VkImageCreateFlags imageCreateFlags", os, indent +1);
    Print(src.imageType, "VkImageType imageType", os, indent +1);
    Print(src.imageTiling, "VkImageTiling imageTiling", os, indent +1);
    Print(src.imageUsageFlags, "VkImageUsageFlags imageUsageFlags", os, indent +1);
}

template <>
inline void Print<VkVideoPictureResourceInfoKHR>(VkVideoPictureResourceInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.codedOffset, "VkOffset2D codedOffset", os, indent +1);
    Print(src.codedExtent, "VkExtent2D codedExtent", os, indent +1);
    Print(src.baseArrayLayer, "uint32_t baseArrayLayer", os, indent +1);
        PrintInterfacePointer(src.imageViewBinding, "VkImageView imageViewBinding", os, indent +1);
}

template <>
inline void Print<VkVideoProfileInfoKHR>(VkVideoProfileInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.videoCodecOperation, "VkVideoCodecOperationFlagBitsKHR videoCodecOperation", os, indent +1);
    Print(src.chromaSubsampling, "VkVideoChromaSubsamplingFlagsKHR chromaSubsampling", os, indent +1);
    Print(src.lumaBitDepth, "VkVideoComponentBitDepthFlagsKHR lumaBitDepth", os, indent +1);
    Print(src.chromaBitDepth, "VkVideoComponentBitDepthFlagsKHR chromaBitDepth", os, indent +1);
}

template <>
inline void Print<VkVideoProfileListInfoKHR>(VkVideoProfileListInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.profileCount, "uint32_t profileCount", os, indent +1);
            if( src.profileCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to profileCount" << std::endl;
            } else {
        PrintPointer(src.pProfiles, "const VkVideoProfileInfoKHR * pProfiles", os, indent +1);
            }

}

template <>
inline void Print<VkVideoReferenceSlotInfoKHR>(VkVideoReferenceSlotInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.slotIndex, "int32_t slotIndex", os, indent +1);
        PrintPointer(src.pPictureResource, "const VkVideoPictureResourceInfoKHR * pPictureResource", os, indent +1);
}

template <>
inline void Print<VkVideoSessionCreateInfoKHR>(VkVideoSessionCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.queueFamilyIndex, "uint32_t queueFamilyIndex", os, indent +1);
    Print(src.flags, "VkVideoSessionCreateFlagsKHR flags", os, indent +1);
        PrintPointer(src.pVideoProfile, "const VkVideoProfileInfoKHR * pVideoProfile", os, indent +1);
    Print(src.pictureFormat, "VkFormat pictureFormat", os, indent +1);
    Print(src.maxCodedExtent, "VkExtent2D maxCodedExtent", os, indent +1);
    Print(src.referencePictureFormat, "VkFormat referencePictureFormat", os, indent +1);
    Print(src.maxDpbSlots, "uint32_t maxDpbSlots", os, indent +1);
    Print(src.maxActiveReferencePictures, "uint32_t maxActiveReferencePictures", os, indent +1);
        PrintPointer(src.pStdHeaderVersion, "const VkExtensionProperties * pStdHeaderVersion", os, indent +1);
}

template <>
inline void Print<VkVideoSessionMemoryRequirementsKHR>(VkVideoSessionMemoryRequirementsKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "void * pNext", os, indent +1);
    Print(src.memoryBindIndex, "uint32_t memoryBindIndex", os, indent +1);
    Print(src.memoryRequirements, "VkMemoryRequirements memoryRequirements", os, indent +1);
}

template <>
inline void Print<VkVideoSessionParametersCreateInfoKHR>(VkVideoSessionParametersCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkVideoSessionParametersCreateFlagsKHR flags", os, indent +1);
        PrintInterfacePointer(src.videoSessionParametersTemplate, "VkVideoSessionParametersKHR videoSessionParametersTemplate", os, indent +1);
        PrintInterfacePointer(src.videoSession, "VkVideoSessionKHR videoSession", os, indent +1);
}

template <>
inline void Print<VkVideoSessionParametersUpdateInfoKHR>(VkVideoSessionParametersUpdateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.updateSequenceCount, "uint32_t updateSequenceCount", os, indent +1);
}

template <>
inline void Print<VkViewport>(VkViewport const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.x, "float x", os, indent +1);
    Print(src.y, "float y", os, indent +1);
    Print(src.width, "float width", os, indent +1);
    Print(src.height, "float height", os, indent +1);
    Print(src.minDepth, "float minDepth", os, indent +1);
    Print(src.maxDepth, "float maxDepth", os, indent +1);
}

template <>
inline void Print<VkViewportSwizzleNV>(VkViewportSwizzleNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.x, "VkViewportCoordinateSwizzleNV x", os, indent +1);
    Print(src.y, "VkViewportCoordinateSwizzleNV y", os, indent +1);
    Print(src.z, "VkViewportCoordinateSwizzleNV z", os, indent +1);
    Print(src.w, "VkViewportCoordinateSwizzleNV w", os, indent +1);
}

template <>
inline void Print<VkViewportWScalingNV>(VkViewportWScalingNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.xcoeff, "float xcoeff", os, indent +1);
    Print(src.ycoeff, "float ycoeff", os, indent +1);
}

template <>
inline void Print<VkWaylandSurfaceCreateInfoKHR>(VkWaylandSurfaceCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkWaylandSurfaceCreateFlagsKHR flags", os, indent +1);
        PrintPointer(src.display, "wl_display * display", os, indent +1);
        PrintPointer(src.surface, "wl_surface * surface", os, indent +1);
}

template <>
inline void Print<VkWriteDescriptorSet>(VkWriteDescriptorSet const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
        PrintInterfacePointer(src.dstSet, "VkDescriptorSet dstSet", os, indent +1);
    Print(src.dstBinding, "uint32_t dstBinding", os, indent +1);
    Print(src.dstArrayElement, "uint32_t dstArrayElement", os, indent +1);
    Print(src.descriptorCount, "uint32_t descriptorCount", os, indent +1);
    Print(src.descriptorType, "VkDescriptorType descriptorType", os, indent +1);
            if( src.descriptorCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to descriptorCount" << std::endl;
            } else {
        PrintPointer(src.pImageInfo, "const VkDescriptorImageInfo * pImageInfo", os, indent +1);
            }

            if( src.descriptorCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to descriptorCount" << std::endl;
            } else {
        PrintPointer(src.pBufferInfo, "const VkDescriptorBufferInfo * pBufferInfo", os, indent +1);
            }

            if( src.descriptorCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to descriptorCount" << std::endl;
            } else {
        PrintPointer(src.pTexelBufferView, "const VkBufferView * pTexelBufferView", os, indent +1);
            }

}

template <>
inline void Print<VkWriteDescriptorSetAccelerationStructureKHR>(VkWriteDescriptorSetAccelerationStructureKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.accelerationStructureCount, "uint32_t accelerationStructureCount", os, indent +1);
            if( src.accelerationStructureCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to accelerationStructureCount" << std::endl;
            } else {
        PrintPointer(src.pAccelerationStructures, "const VkAccelerationStructureKHR * pAccelerationStructures", os, indent +1);
            }

}

template <>
inline void Print<VkWriteDescriptorSetAccelerationStructureNV>(VkWriteDescriptorSetAccelerationStructureNV const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.accelerationStructureCount, "uint32_t accelerationStructureCount", os, indent +1);
            if( src.accelerationStructureCount == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to accelerationStructureCount" << std::endl;
            } else {
        PrintPointer(src.pAccelerationStructures, "const VkAccelerationStructureNV * pAccelerationStructures", os, indent +1);
            }

}

template <>
inline void Print<VkWriteDescriptorSetInlineUniformBlock>(VkWriteDescriptorSetInlineUniformBlock const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.dataSize, "uint32_t dataSize", os, indent +1);
            if( src.dataSize == 0) {
                std::string largerIndent((indent + 1 ) * 4, ' ');
                os << largerIndent << srcName << "is empty, refer to dataSize" << std::endl;
            } else {
        PrintPointer(src.pData, "const void * pData", os, indent +1);
            }

}

template <>
inline void Print<VkXYColorEXT>(VkXYColorEXT const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.x, "float x", os, indent +1);
    Print(src.y, "float y", os, indent +1);
}

template <>
inline void Print<VkXcbSurfaceCreateInfoKHR>(VkXcbSurfaceCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkXcbSurfaceCreateFlagsKHR flags", os, indent +1);
        PrintInterfacePointer(src.connection, "xcb_connection_t * connection", os, indent +1);
    Print(src.window, "xcb_window_t window", os, indent +1);
}

template <>
inline void Print<VkXlibSurfaceCreateInfoKHR>(VkXlibSurfaceCreateInfoKHR const& src, std::string srcName, std::ostream & os, size_t indent ){
    (void) src;
    std::string indentString(indent * 4, ' ');
    os << indentString << srcName << std::endl;
    Print(src.sType, "VkStructureType sType", os, indent +1);
        PrintPointer(src.pNext, "const void * pNext", os, indent +1);
    Print(src.flags, "VkXlibSurfaceCreateFlagsKHR flags", os, indent +1);
        PrintInterfacePointer(src.dpy, "Display * dpy", os, indent +1);
    Print(src.window, "Window window", os, indent +1);
}